---
title: "Announcing XI Parallax: Provenance for Images That Lost It"
description: "Phones, cameras and AI generators now write provenance into images, and a screenshot, a crop or a re-save still takes it away. XI Parallax recovers an image's manifests from the picture itself, for newsrooms, agencies and creators, AI image providers, and the platforms in between."
author: "I.Livingston-Scialfa and K.D. Cavner - Co-Founders"
published: 2026-09-23T16:47:08.68397+00:00
updated: 2026-09-23T16:47:08.68397+00:00
tags: ["ai", "announcement", "attribution", "c2pa", "images", "parallax", "provenance", "soft-binding"]
url: https://xiobjects.com/articles/announcing-xi-parallax
source: XI Objects
---

<!-- xion:doctype xion+markdown -->
<!-- xion:metadata
{
  "version": "1.0",
  "content_type": "application/xion\u002Bmarkdown",
  "source_type": "xi-content/article",
  "generator": "xio-content-publisher/1.0.0",
  "generated": "2026-09-23T16:46:43.6126726\u002B00:00",
  "encoding": "utf-8",
  "render_intent": "html",
  "title": "Announcing XI Parallax: Provenance for Images That Lost It",
  "slug": "announcing-xi-parallax",
  "author": "I.Livingston-Scialfa and K.D. Cavner - Co-Founders",
  "license": "CC-BY-4.0",
  "copyright": "\u00A9 2026 XI Objects Inc"
}
-->

# Announcing XI Parallax

More images carry provenance today than ever before. Google's Pixel 10 phones attach Content Credentials to every photo taken with Pixel Camera. Generative AI providers serving Europe and California now have legal duties to mark what their systems produce. Newsrooms, agencies and platforms have spent years building on the C2PA standard so that an image can say who made it, what was done to it, and when.

Then the image leaves.

It gets reposted, and the platform re-encodes it. Someone takes a screenshot. Someone else crops it, saves it and posts it again. Each step is ordinary, and each one can keep the picture and lose the record. By the time the image reaches the person who needs to know where it came from, it is a damaged copy with no history at all.

Today we're announcing **XI Parallax**, XI Objects' soft binding for image provenance. Parallax recovers an image's provenance from the picture itself.

A creator registers an image once, with the manifests that say who made it and on what terms. From then on, anyone who finds a copy of that image, cropped, re-encoded, screenshotted or otherwise damaged, can look it up and get those manifests back. It does not matter which account registered the image, and it does not matter that the file in their hands lost its metadata years ago.

Register once. Recover anywhere.

**Parallax at a glance**

- **What it does.** Recovers an image's manifests from a damaged copy of it.
- **Who it's for.** Newsrooms and publishers, photo agencies and creators, AI image providers, and platforms and marketplaces.
- **What's different.** Nothing is embedded in the image, copies already in circulation are covered, every verdict is deterministic, and every record is signed.
- **Proof.** 95.0% end to end on mild and moderate damage against a million reference images, at 180 ms a query.
- **Availability.** Private access and design-partner pilots now. Open look-up at general release.

---

## The Label Comes Off

A **C2PA manifest** is an image's provenance record: who made it, what was done to it, and when. It travels inside the file, and that is its weakness. A repost re-encodes the file. A screenshot keeps the pixels and drops the metadata. A crop or a re-save writes a new file, and the manifest stays behind in the old one.

A manifest is a luggage tag. A repost, a screenshot or a crop is the baggage belt tearing it off, and what arrives is one anonymous black suitcase in a mountain of them.

That is the normal life of an image online, and it is expensive for everyone who depends on the record:

- **Creators and agencies** lose the credit line, and with it the licensing contact that would have brought a buyer back to them.
- **Newsrooms** spend verification time on pictures whose origin was known the moment they were made.
- **AI image providers** label their outputs, and the metadata label disappears at the first screenshot.
- **Platforms** are asked to display provenance on uploads that arrive already stripped.

The pixels survive the trip. The record has to be recoverable from them.

![An image with its manifest badge passes through a repost, a screenshot and a crop, and arrives with no manifest. The badge falls away along the way.](https://stxiopublic.blob.core.windows.net/content/announcing-xi-parallax/f09b115752619c6dbda443539c2248c0c37690d5946e4ddafbe328d7a0ee78d8.webp#xi=acc01f64dcc852681a314c79c45b5e81e005d1f8996829bf0498d987123a19a5)

---

## Why Now

Two sets of rules took effect this summer, and both expect provenance to be found after an image has traveled.

In the European Union, the transparency obligations in Article 50 of the AI Act have applied since 2 August 2026, with a grace period to 2 December 2026 for the marking duty on systems already on the market. Providers of generative AI systems must ensure their outputs are "marked in a machine-readable format and detectable as artificially generated or manipulated," with technical solutions that are "effective, interoperable, robust and reliable as far as this is technically feasible." The Commission's Code of Practice on marking and labelling expects signatories to layer digitally signed metadata with imperceptible watermarking.

In California, the AI Transparency Act became operative the same day. Large generative AI providers must embed latent disclosures in the images they produce, and offer a free detection tool, with API support, that tells anyone whether content came from their system. From 1 January 2027, large online platforms must detect standards-compliant provenance data in the content they carry, let users inspect it, and not knowingly strip it. From 2028, capture devices first produced for sale in California must embed disclosures by default.

Both rules point the same way. More images will carry a record from the moment they are made, and more parties will be expected to find it. A platform can only show the provenance it can detect, though, and a rule against stripping metadata does nothing for the screenshot someone took before the upload. The record has to be recoverable from the picture itself.

---

## What Parallax Does

C2PA ties a manifest to its image in two ways. A **hard binding** is a cryptographic hash of the asset. Change a single pixel and it stops matching, which is how it proves the file is untouched. A **soft binding** is for the file that has been touched. It identifies an image by its content, so that an image and a copy of its manifest kept somewhere else can find each other again.

Parallax is XI Objects' answer to soft binding. It is a REST service with two primary calls.

**Register.** A creator sends an image with its manifests: a C2PA manifest, their own JSON, whatever they want the world to read. Parallax checks the image against everything already registered, derives what its engine needs, and discards the pixels. It signs the image hash, each manifest and the set as a whole with the XIO SDK, and publishes the signed record on the Orbital network.

**Look up.** Anyone holding a copy sends it, and nothing else. The answer is binary: registered or not. When the image is registered, the answer points to the original, whichever copy was sent, and one more request returns the original's manifests exactly as they were registered.

```
┌──────────────────────────────────────────────┐
│  Register an image and its manifests         │
│  POST /registrations                         │
└────────────────────┬─────────────────────────┘
                     │ signed and published
                     ▼
┌──────────────────────────────────────────────┐
│  Look up any copy, crop or derivative        │
│  POST /lookup                                │
└────────────────────┬─────────────────────────┘
                     │ original image hash
                     ▼
┌──────────────────────────────────────────────┐
│  Recover the manifests, as registered        │
│  GET /records/{originalImageHash}            │
└──────────────────────────────────────────────┘
```

Behind those calls, three stages do the work. **P1, Find,** looks at the copy and proposes the five most plausible originals. It proposes, and it does not decide. **P2, Verify,** accepts nothing without demonstrated agreement between the two images. **Decide** accepts or rejects, with the evidence attached.

Damage rarely touches everything. A crop takes the edges, a re-encode softens the detail, a rotation turns the frame, and the arrangement of what is in the picture survives all three. A constellation seen through a blurry telescope, or with a building hiding half the sky, keeps the same distances between the stars you can still see. A damaged copy keeps its arrangement the same way, and that is what Parallax compares. Parallax is neither a generative model nor a fingerprint.

![Three versions of one image, original, rotated and rescaled, cropped and re-encoded, with the same six points and the same distances between them picked out on all three.](https://stxiopublic.blob.core.windows.net/content/announcing-xi-parallax/9cc4f099214678dd87b8634accfe85255c920139765c4f5d666ac8c9485c9820.webp#xi=898c0744b0b2366d20fb26f7976723068bbbd64df485d45991fceca46f7d6835)

Parallax changes nothing in the image. There is no watermark to embed and none to strip, and the file you publish stays as it was.

It is also the complement to **XION**. A XION artifact carries its proof inside the content, so a signed document can verify itself anywhere, even on an air-gapped machine. An image can't count on keeping anything inside the file, because every platform it passes through is free to rewrite its bytes. XION keeps the proof with the content. Parallax recovers it from the picture. Parallax is how XI Objects provides attribution for images.

---

## Who It's For

### Newsrooms and Publishers

At 11 p.m., a photo of a flooded street is climbing every feed at once. The night desk wants it for the morning edition. The copy they have is a screenshot of a repost, and its metadata is long gone. Who shot it? Can they run it, and who do they credit?

With Parallax, the desk sends that screenshot to look-up. If the original is registered, the answer points to it, and the records request returns what the creator registered with it: typically who made the picture and under what license, and a C2PA manifest with its history of edits if they attached one. The copy the desk started with never carried any of that. The original's record did, and Parallax connects the two.

If there is no match, the desk knows that too. A "no" means no registered original matched. It is not a finding that the picture is fake, and Parallax never presents it as one.

Publishers sit on the other side of the same problem. Register your own photography when you publish it, and the copies that get lifted, cropped and re-shared resolve back to you, and to the credit and license you attached.

Three properties matter most to an editor:

- **The answer holds up.** The same question against the same archive returns the same answer today and in five years, and an accept must be earned by demonstrated agreement between the two images. When a credit is challenged, the evidence is there to be argued about.
- **Sources stay protected.** An image sent to look-up goes to Parallax and nowhere else. Its pixels are deleted as soon as the verdict is in, and their absence is verified.
- **The record speaks for itself.** Every record is signed, and its certificate chain leads to the XI trust root, so the desk can check the record instead of taking Parallax's word for it.

### Photo Agencies and Creators

An agency with twenty years of archive has watched its work travel without it. The credit line fell off somewhere in the first repost, and with it the licensing contact that would have brought a buyer back.

Parallax covers those copies from the day the original is registered. Matching reads the picture itself, so a copy that left your archive years ago can be traced back as soon as its original is registered. There is nothing to add to your images first, and nothing to re-export or re-deliver.

Register the archive in batches. A batch is a workspace: open one, upload images across as many requests as you need, check what it holds, then commit. Nothing registers until you commit, and one bad file never fails the rest.

What you register is what the world gets back. Attach a C2PA manifest, your own JSON, or both: the creator, the credit line, license terms, a licensing contact. When someone finds a copy and looks it up, those manifests come back exactly as you registered them.

Ownership is protected from the first registration. Only one account can hold a live registration for a given original at a time, and the check is global. A crop or an edit of your registered image is refused as a derivative, so trimming the edges off your photograph is not a way for someone else to claim it. Registration is first come, which is one more reason to register an archive early.

You also stay in control of what is public. A record never names the account that registered the image. A reader learns what you chose to put in the manifests, and nothing else. If you need to withdraw an image, a take-down stops it matching for everyone and removes its manifests.

### AI Image Providers

A generative AI provider labels every image it produces. The signed metadata says the picture is AI-generated, which system made it, and when. A user downloads the result, takes a screenshot to share it, and posts the screenshot. The metadata did not make the trip.

Both sets of rules expect those marks to hold up. The EU asks for marking that is robust and reliable "as far as this is technically feasible." Metadata is the layer a screenshot removes first. Watermarks help, and the Code of Practice expects them, but a watermark carries a signal, and the full record still has to come from somewhere.

Register each output with its manifest when it is generated. From then on, a copy of that image, screenshotted, cropped or re-encoded, can be looked up, and the manifest comes back: AI-generated, by this system, on this date, under these terms. The label is recovered from the picture, whatever happened to the file.

That gives you something to build on. California asks large providers to offer a free detection tool with API support. Parallax look-up is an API that answers from the picture itself, which is what a detection tool has to do once the metadata is gone.

Parallax adds nothing to your outputs. There is nothing to embed, so there are no artifacts to tune and no mark in the image to strip. Parallax is not a compliance program on its own, and we don't present it as one. It is the layer that keeps working after the metadata has been stripped away.

If you generate at volume, ask us about a design-partner pilot.

### Platforms and Marketplaces

From 1 January 2027, large online platforms serving California must detect standards-compliant provenance data in the content they carry, let users inspect it, and not knowingly strip it. Platforms that already display Content Credentials know the catch: you can only show what arrives. Many uploads are screenshots and re-saves of images that lost their record somewhere else, long before they reached you.

Parallax gives your upload pipeline a second chance to find it. At ingest, send the image to look-up. If it derives from a registered original, you get the original's hash, and the records request returns its manifests with the signatures to verify them. The credential that fell off upstream can be shown again downstream, on a copy that arrived without one, as the record of the original that copy came from.

For marketplaces, the same look-up answers a harder question before a listing goes live: is this upload someone else's registered work? A crop, a re-encode or a derivative resolves to the original it came from. Parallax tells you the match exists and points to the original. It never tells you which account registered it. The manifests say what the registrant chose to say.

Volume work runs through look-up batches. Upload query images into a batch, commit, and the results come back in the same response. A query the engine will not serve is never reported as no match, so your pipeline can tell "not registered" from "try again."

Query images are handled the way a trust and safety team would want. The pixels are held only as long as the engine needs to answer, then deleted, and their absence is verified. Nothing else leaves on a look-up.

At general release, look-up and the records request open to everyone without a token, so your users and moderators can check an image the same way your pipeline does.

---

## How Parallax Compares

There are other ways to keep provenance with an image. Each one is good at something, and each leaves a gap.

**Embedded metadata** is the record itself, and it is only as durable as the file that carries it. It is the first thing a screenshot removes.

**Invisible watermarks** survive more handling, but a watermark has to be embedded before the image leaves, it changes the pixels to get there, and it covers only images marked from that day on. It carries a signal, and the record still has to be found somewhere else.

**Reverse image search** finds pictures that look alike. It returns a list of candidates and leaves the verdict to you, it does not return the creator's record, and the image you search with goes to a third party.

**Perceptual fingerprints** survive more damage than a cryptographic hash. C2PA's own specification describes a fingerprint as an identifier that is "not statistically unique," which is why a fingerprint match on its own is a lead rather than an answer.

Parallax takes a different path. Nothing is embedded, so images already in circulation are covered from the day their original is registered. Find proposes candidates, Verify demands demonstrated agreement, and the answer is binary and deterministic. What comes back is the creator's own record, signed. The image you look up goes to Parallax and nowhere else.

None of this asks you to give up what you already use. Keep the signed metadata and the watermark. Parallax is the layer that does not depend on anything surviving inside the file.

---

## Measured at a Million

We measure Parallax against **1,000,000 reference images**, on a single conventional server with no accelerators, using a public copy-detection benchmark. The queries carry the damage a real archive contains: recompression, resizing, color shifts and ordinary crops.

| Measure | Result | What it counts |
|---|---:|---|
| **Find** | 98.5% | True source in the top five |
| **Verify** | 96.5% | True matches accepted |
| **End to end** | 95.0% | 98.5% found × 96.5% verified |
| **Time per query** | 180 ms | Flat from fifty thousand to one million references |
| **Wrongly accepted** | 1 in 1,500 | Unrelated images on a uniform random sample, a ceiling |

Find, Verify and end to end are measured on mild and moderate damage at one million reference images, with narrowing off. Mild damage is one ordinary edit, the kind any pipeline applies: a resize, a recompression, a color shift, a crop, a rotation, a watermark, one at a time. Moderate damage is harder and often combined, though still one generation of the file: a severe crop, an off-axis rotation with a crop, compression with blur, noise with compression, a watermark with a rotation. Extreme damage is several edits in sequence, re-encoded between each, the way a real repost cycle compounds them. It is measured too, and reported separately on the [Parallax site](https://parallax.xiobjects.com).

A twentyfold larger archive cost nothing in accuracy or speed:

| Reference images | P1 Find | P2 Verify | Query time |
|---:|---:|---:|---:|
| 50,000 | 98.5% | 96.3% | 195 ms |
| 100,000 | 98.7% | 96.1% | 191 ms |
| 250,000 | 98.7% | 96.3% | 182 ms |
| 1,000,000 | 98.5% | 96.5% | 180 ms |

*Find and Verify on mild and moderate damage. Query time is the mean across the same 1,000 queries at each size.*

The queries that succeeded at fifty thousand references were the same ones that succeeded at a million. Little of the work a query does depends on the size of the archive.

The benchmark was adversarial by design, built to defeat copy detection with multi-stage transform chains. Real derivatives, a repost, a crop, a re-save, are far gentler. Read every number here as a floor.

---

## Built to Hold Up in a Dispute

A soft binding is tested when someone pushes back: a photographer disputing a credit, a newsroom defending a caption, a marketplace explaining why a listing came down. Parallax is designed for that conversation.

**Deterministic.** The same question against the same archive returns the same answer today and in five years.

**Cannot invent a match.** An accept must be earned by demonstrated agreement between the two images. Parallax is designed to fail by not finding, rather than by finding the wrong thing.

**Inspectable.** Every verdict rests on quantities a person can examine. If a rights holder or a newsroom disagrees, the evidence is there to be argued about.

**No third party.** An image sent to Parallax goes to Parallax and nowhere else. No third-party service is involved, and the matching runs on ordinary CPUs, with no accelerators.

The record is built the same way. Every published record carries two kinds of attestation from the same key: an Ed25519 signature over the original image's content hash, and a signature over each manifest that binds it to that image. A collection signature covers the whole set, so nothing can be added to a record or taken out of it, and a manifest can't be moved from one record to another. The key chains to the XI trust root. Parallax verifies nothing on your behalf: it hands you what was published, and you check it yourself.

Records also stay what they were. There is no manifest update on a registered image, ever. The only change a registrant can make is a take-down, and a take-down is final: the image stops matching for everyone, and its manifests are removed with it.

---

## Your Images Stay Yours

Parallax is not in the business of holding images.

A registration image is hashed and handed to the one engine call it will ever make. The instant that call answers, its buffer is zeroed and the zero is verified. No registration image byte is written to storage: not to a blob, not to a column, not to a log. A look-up holds the query's pixels only as long as the engine needs to answer, then deletes them and verifies they are gone.

Every moment an image spends in custody is written to an append-only ledger, from receipt to verified deletion. When an auditor asks what happened to a specific image, the operator can export that ledger for your account.

What a registration keeps, until you take it down, is the image's SHA-256, your manifests as you gave them, and the engine's outcome record. None of it is image bytes.

The manifests are the part that is meant to be read. Any token holder can read them during the beta, and anyone can at general release, because attribution that only its own author can read is not attribution. What a record never carries is account detail. There is no way to ask Parallax which account registered a given image. A reader learns what the registrant chose to put in the manifests, and nothing else.

---

## For Your Engineers

Parallax is plain REST at `https://api.parallax.xiobjects.com`, with a bearer token during the beta. Registering an image, finding a copy and recovering its attribution look like this:

```bash
# Register an image with its manifests
curl -sS -X POST "$BASE/registrations" \
  -H "Authorization: Bearer $TOKEN" \
  -F 'manifest[xi-manifest]={"creator":"Ada Lovelace","license":"CC-BY-4.0"};type=application/json' \
  -F "manifest[c2pa]=<manifest.jumbf;type=application/jumbf" \
  -F "image=@photo.png;type=image/png"

# Anyone holding a copy looks it up
curl -sS -X POST "$BASE/lookup" \
  -H "Authorization: Bearer $OTHER_TOKEN" \
  -F "image=@copy.jpg;type=image/jpeg"

# Recover the attribution with the original image's hash
curl -sS "$BASE/records/$ORIGINAL_IMAGE_HASH" \
  -H "Authorization: Bearer $OTHER_TOKEN"
```

- **Formats.** The beta accepts JPEG, PNG and WebP.
- **Manifests.** Each manifest states its own kind, as JSON or as C2PA JUMBF, and comes back exactly as registered. Nothing is re-encoded, reordered or normalized on the way.
- **Verification.** `Xio.Verification` checks each manifest and the set as a whole, and answers `Verified`, `NotSigned` or `Invalid`.
- **Batches.** Registration and look-up both have batch workspaces. Nothing registers until you commit, and one entry's outcome never affects another's.
- **Refusals.** Every refusal is standard `application/problem+json`, with a fixed sentence that never quotes your image or your manifests back at you. A refused item is never read as no match, and never accepted.
- **Contract.** The OpenAPI document is at `https://api.parallax.xiobjects.com/openapi/v1.json`, and reading it takes no token.

The [REST API documentation](/docs/xio/parallax/rest-api) walks through the whole product in four calls.

---

## Private Access and Design Partners

Parallax is offered as a REST API to a private group first. During the closed beta, XI Objects issues each account its API token, and look-up and records calls need one too.

We are also taking on design partners. If you run a newsroom, an agency or an archive, a generative AI service, or a platform, and you want to put Parallax to work on your own images and your own pipeline, request access and we'll talk about a pilot.

At general release, look-up and the records request open to everyone without a token, so anyone can find a registered image and recover its attribution. Registration and take-down stay with token holders. That is the commitment Parallax makes to everyone who registers: their attribution can be found by anyone, regardless of account.

The images in this article are registered with Parallax. If you hold a beta token, crop one, re-save it and look it up.

Labels will keep coming off. Parallax is how the record finds its way back.

---

**XI Parallax**: Register once, recover anywhere.

[Request access →](https://parallax.xiobjects.com)  
[Read the documentation →](/docs/xio/parallax)  
[Start with the REST API →](/docs/xio/parallax/rest-api/getting-started)
<!-- xion:trust
{
  "v": 1,
  "canon_v": 1,
  "ctx": "xiobjects.com/content",
  "hash_blake3_hex": "78140c1407dca1249d89e7ef14d86aa54673fcc68962bb1662c49d85c8fdacdf",
  "hash_sha256_hex": null,
  "sig_alg": "ed25519",
  "sig_b64": "HonbB-dw77skubSo7FVpnlguuxtp0cH28VCzdn_A61giBGbPnabF5mi4mOR1JQZrLLjDCQOXbGfMwj5ewNADBg",
  "pubkey_b64": "kqrou5_8ST-4UPBaeqvkGqv9epFlnG7gJflBvoUSEwE",
  "x509_chain_pem": [
    "-----BEGIN CERTIFICATE-----\nMIIB9TCCAaegAwIBAgIRAKd8cEG/OyHH42YG7D50rZYwBQYDK2VwMC4xLDAqBgNV\nBAMMI1hJIE9iamVjdHMgSW5jIENvbnRyb2wgSW50ZXJtZWRpYXRlMB4XDTI2MDky\nMzE2NDE0M1oXDTI2MTAyMzE2NDE0M1owSzEeMBwGA1UEAwwVeGlvLWNvbnRlbnQt\ncHVibGlzaGVyMRcwFQYDVQQKDA5YSSBPYmplY3RzIEluYzEQMA4GA1UECwwHQ29u\ndGVudDAqMAUGAytlcAMhAJKq6Luf/Ek/uFDwWnqr5Bqr/XqRZZxu4CX5Qb6FEhMB\no4G8MIG5MAwGA1UdEwEB/wQCMAAwDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoG\nCCsGAQUFBwMkMGUGA1UdIwReMFyAFDspt5hZsP6rNX4Cq7owpMYa05OyoS6kLDAq\nMSgwJgYDVQQDDB9JbnN0aXR1dGUgb2YgUHJvdmVuYW5jZSBSb290IENBghRSYDf4\nsUJ\u002B9h\u002Bod0\u002BZRK/X/JSUBTAdBgNVHQ4EFgQUjZEc1jg8H3At3WVudjvo20AOpCEw\nBQYDK2VwA0EAkyztWpP0dbzJUdxBK0Tv9Zl/OHb6\u002BXrMl9D94eBTsX/sa84m//bP\naZbgNklNDPcJ\u002Btqy87DAd5eFY/LIs\u002BhbAQ==\n-----END CERTIFICATE-----\n",
    "-----BEGIN CERTIFICATE-----\nMIIByDCCAXqgAwIBAgIUUmA3\u002BLFCfvYfqHdPmUSv1/yUlAUwBQYDK2VwMCoxKDAm\nBgNVBAMMH0luc3RpdHV0ZSBvZiBQcm92ZW5hbmNlIFJvb3QgQ0EwHhcNMjUxMTAy\nMDMxNzEyWhcNMzAxMTAxMDMxNzEyWjAuMSwwKgYDVQQDDCNYSSBPYmplY3RzIElu\nYyBDb250cm9sIEludGVybWVkaWF0ZTAqMAUGAytlcAMhAFSS/pggSRmTcAMko7uc\nATH8OHgxVymd5mBFlPXbJkgio4GtMIGqMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYD\nVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBQ7KbeYWbD\u002BqzV\u002BAqu6MKTGGtOTsjBlBgNV\nHSMEXjBcgBQAZRTDswSVORu\u002BkUOKX6WvrOvmQKEupCwwKjEoMCYGA1UEAwwfSW5z\ndGl0dXRlIG9mIFByb3ZlbmFuY2UgUm9vdCBDQYIUJqoJlpiSFg\u002B7W5IJLMrLttgR\nQp4wBQYDK2VwA0EA5FOht7YOsVRPp/FOKMQ\u002B3Mo9JxrvGR3ylKWAWNm6OUV7N3DB\nI9cD62wU5I0d0EKDBy0CX9DnoqUyxv5yguraAA==\n-----END CERTIFICATE-----\n",
    "-----BEGIN CERTIFICATE-----\nMIIBaTCCARugAwIBAgIUJqoJlpiSFg\u002B7W5IJLMrLttgRQp4wBQYDK2VwMCoxKDAm\nBgNVBAMMH0luc3RpdHV0ZSBvZiBQcm92ZW5hbmNlIFJvb3QgQ0EwHhcNMjUxMTAy\nMDMwNTEyWhcNMzUxMDMxMDMwNTEyWjAqMSgwJgYDVQQDDB9JbnN0aXR1dGUgb2Yg\nUHJvdmVuYW5jZSBSb290IENBMCowBQYDK2VwAyEAEWNZl\u002Br3IC7\u002BgBh90Yo1kWk1\npZCVzVuFdFT7qBBU8W2jUzBRMB0GA1UdDgQWBBQAZRTDswSVORu\u002BkUOKX6WvrOvm\nQDAfBgNVHSMEGDAWgBQAZRTDswSVORu\u002BkUOKX6WvrOvmQDAPBgNVHRMBAf8EBTAD\nAQH/MAUGAytlcANBAO6QeydOFNrN75qNyftggYudsxMyl4w9qWkSdZ6hlhrRcbSr\niG9Si0kbrIJOwYB/LTBU0RM4Rl\u002Bo9PM3Qp0mPwo=\n-----END CERTIFICATE-----\n"
  ],
  "key_id": "pK5R5TANF8W9_-0rqgnj82LCP2bg8J263OQcSnrjScc",
  "created_at": "2026-09-23T16:46:43Z"
}
-->