Refresh a Protocol from Its URL
When a publisher updates a protocol you have imported, pick up the new document without deleting and re-importing it.POST /api/admin/protocols/{id}/refresh (scope admin:protocols:write)
fetches the protocol again from its URL and stores the new document as the
next revision, but only when every import check passes and every backend that
references the protocol still fits it. Send {"dry_run": true} to run the
checks without writing. The result is unchanged, update_available, or
updated. GraphQL offers the same operation as the refreshProtocol
mutation. Protocol summaries now carry revision and updated_at.A refresh that cannot apply returns 409 PROTOCOL_ID_CHANGED when the
document’s $id changed, 409 REFRESH_CONFLICT when another refresh
finished first, 422 VALIDATION_ERROR with one entry per incompatible
backend at backends.<backend_id>, 422 FETCH_FAILED, or 503
AUDIT_UNAVAILABLE. A stored Specter protocol is refreshed at instance
startup only when SPECTER_AUTO_REFRESH_ENABLED is on, which it is not by
default.Link does not follow redirects, and the Specter v1 URL redirects, so Link now
fetches Specter v1 from https://developer.hellgate.io/static/specter-v1.json
on import and refresh. The protocol keeps its URL. See
Refresh a protocol.Client Certificates for Mutual TLS
Connect to providers that accept only callers presenting a certificate they issued. Upload the certificate, its chain, and its unencrypted private key as a key with the new purposeclient_tls, and name it in the backend’s new
tls field: {"client_key_kid": "<kid>"}. Every call to that backend then
presents the certificate, over HTTP/1.1. Link validates the bundle on upload
and refuses to delete a key that a backend still references. A bundle with a
certificate that has expired or is not yet valid is rejected, and the key’s
not_before and not_after come from the leaf certificate. Configuration
can no longer weaken server certificate verification on outbound calls. See
Client certificates.Breaking change: algorithm and encryption_method in encryption key
responses can now be null, in REST and in GraphQL (algorithm,
encryptionMethod). They are null for client_tls keys only. If your
integration reads them from every key, accept null or skip client_tls
keys before you create the first one.Breaking change: raw_response in execution responses can now be any JSON
value, not only an object. Link now keeps a provider body that is a JSON
array, string, number or null as it is, where it used to store {}. If your
integration reads raw_response as an object, check its type first.Combine Provider Fields with map
A map filter value can now be a path, resolved only when its entry matches,
and map takes an optional default: for an input that matches no key or is
null. Two chained map filters turn two provider fields into one protocol
value. See
Template grammar.Paths inside filter arguments are now checked against their scope: a request
mapping that uses $.response.* in a filter argument, such as default(...),
is rejected when you save the backend. Such an argument always resolved to
null. Backends already stored keep running.Improvements and Bugfixes
- Providers that answer errors unencrypted work with message-level
encryption. A non-
2xxresponse without the encryption envelope is mapped through your error mapping instead of failing withDECRYPT_FAILED. A2xxresponse must still be encrypted. - A backend connection’s
endpoint.timeout_msnow applies: Link stops waiting after that many milliseconds without response data and returns a502error with"source": "transport"and the code:timeout. - A
2xxresponse whose body is not JSON, such as an HTML page from a proxy, is now a502error with"source": "transport"instead of reaching your success mapping. A body that is not valid UTF-8 or contains a NUL byte is the same error on every status, and the execution log keeps only its size. - A protocol URL without a
/protocols/segment can be imported: its local ID is built from all path segments. - A protocol delete can no longer race a backend create on the same protocol.
When its audit event cannot be recorded, the delete is not applied and
returns
503AUDIT_UNAVAILABLE. - The console configures client certificates on the backend page, accepts
paths and
default:inmap, and checks a protocol for updates.
Changed
- Saving a backend checks response mappings more strictly. A literal value
must equal the
constthe protocol schema declares for it, so"type": "enum"no longer matches the error branch. Objects with legacypath,constorcomposekeys are now checked like any other object. A mapping that saved before can now fail with422VALIDATION_ERRORon its next save. Backends already stored keep running. - Backend create and update accept
endpoint.timeout_msonly from1to60000. Stored values above the maximum keep applying as stored. - Importing a URL whose local ID belongs to a protocol with a different URL
returns
422VALIDATION_ERRORinstead of409.
Trusted Root Certificates Updated
For outbound connections, Link no longer trusts the emSign G3 root certificates from eMudhra or theAAA Certificate Services root. If a
provider endpoint one of your backends calls presents a certificate chain that
ends only at one of these roots, the backend action fails with a 502 and
"source": "transport". The provider needs to present a chain to another
publicly trusted root.Execution Log Entries Expire After 30 Days
Link now keeps execution log entries for a finite window — 30 days by default, set per instance — and deletes them in full once it has passed. Until now an instance without an explicit window kept every entry, including the raw provider response, indefinitely. The change aligns Link with the defined retention period PCI DSS requires for stored account data and with how Specter already ages out provider payloads.What to check on your side:- Fetching an expired execution returns
404. If you look up executions by ID after the fact — for reconciliation or dispute handling — do so within the window, or export the entries you need before it closes. - The window is fixed per instance. Talk to us if your instance needs a different period; an unlimited window is no longer available.
Provider Calls Reach the Provider You Configured
Link verifies a backend’s address before it connects and holds the call to that verified address for its whole duration, closing a class of network attack in which a call meant for your provider is diverted to another destination. Nothing changes in how you configure a backend, and no action is needed for this protection to apply.Two points are worth checking against backends you already run:- A backend needs its final address. Link does not follow redirects. A
provider endpoint that answers with a
3xxshould be configured with the address it redirects to. - Providers that verify our signature from behind a path prefix. If a backend’s base URL includes a path prefix and your provider checks the signature Link sends, verify it against a live request once — the signature now covers the full address the request is actually sent to.
Improvements and Bugfixes
- Editing a backend’s authentication pipeline in the console saves what you entered. Header changes were discarded on save, and saving could drop settings that had been configured through the API — a provider could be left authenticating differently than intended. Both are fixed.
- A long request body or response mapping can be edited all the way to the end. The JSON editor was cut off at a fixed height, so a body past a certain length could not be scrolled to or corrected without going through the API; it now fills the dialog and scrolls.
Run Link Within SAQ A and SAQ A-EP Scope
Link now runs on instances assessed at SAQ A or SAQ A-EP — you no longer need a SAQ-D environment to invoke protocols. Below SAQ-D, Link enforces the boundary that keeps your assessment scope small: invoke request bodies carrying a raw card number (PAN) are rejected with a422 validation error.
At SAQ-D and above, your protocol schema decides which attributes
legitimately carry card data. Admin routes are exempt at every level, so
backend mappings and protocol specs can keep example card numbers.The platform test-card policy applies on every instance: on the Test tier,
only known test cards pass; on the Production tier, test cards are rejected
while real card numbers flow as your protocol allows.