> ## Documentation Index
> Fetch the complete documentation index at: https://docs.blockgence.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Blockgence public key

> The Ed25519 key Blockgence signs its documents with, its fingerprint, the three places it is published and what happens when it is rotated or revoked.

Blockgence signs every sealed document with an **Ed25519** key. To check that a document was issued by Blockgence, compare the fingerprint of the key that signed it (`key_id`) with the one we publish here.

## The current key

> [!NOTE]
>
> **Current since 13 Nov 2026.** Ed25519 algorithm. The fingerprint (`key_id`) is the sha256 of the public key's 32 raw bytes.

```text key_id theme={null}
sha256:d8853d1c1b7322b8b7e3bab730fccd0652c0c97a825c3317b3bc705d650f5c5f
```

```text PEM theme={null}
-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAro3Bpht0HXDL35PmxRYoDKMwaeX3rlBcCqCYszHaW20=
-----END PUBLIC KEY-----
```

```text Base64 (32 raw bytes) theme={null}
ro3Bpht0HXDL35PmxRYoDKMwaeX3rlBcCqCYszHaW20=
```

To use it with OpenSSL, save the PEM block to a file, for example `blockgence-evidencia.pub.pem`. It can also be downloaded from the [Verify page on the website](https://www.blockgence.com/en/verify.html).

## Why you need to compare it

Every signed document carries its own copy of the public key, in `manifest.integrity.attestations.signature`. That copy lets you verify the signature without asking for anything, but **on its own it proves nothing**: anyone can strip Blockgence's signature and sign with another key.

What proves the document was issued by Blockgence is that its `key_id` is the one on this page. That is why, when you [verify a signature](https://docs.blockgence.com/en/methodology/verify-signature.md), you use the key downloaded from here and not the one the document carries.

## Where it is published

The same fingerprint is published through three channels, which must say the same thing:

> [card] [The website](https://www.blockgence.com/en/verify.html)
>
> `www.blockgence.com/en/verify.html` (and `/verificar.html`). The key is written into the HTML: it is not requested from the signing server.

> [card] The API
>
> `GET /v1/evidence/signing-key`, open: no API key, no session and no credits.

> [card] This documentation
>
> This page, with the same registry.

> [!NOTE]
>
> The website does not ask the server for the key, on purpose: if the signing server were compromised, it could also serve a different key. When in doubt, the reference is the one published on the website.

## The key from the API

```bash theme={null}
curl https://app.blockgence.com/v1/evidence/signing-key
```

The response carries two different things:

* **`configured`**: the key that server signs with today, derived from its private key (never the private key itself). If the server has no key, it is `null` and `configured_note` says why.
* **`published`**: Blockgence's versioned key registry, with the current, retired and revoked keys and their periods. This is the fingerprint worth comparing.

`matches_published` says whether the configured key is the current published one. If it is `false`, that is a warning: the server signs with a key that is not published yet, or with a retired or revoked one.

```json theme={null}
{
  "configured": {
    "algorithm": "ed25519",
    "key_id": "sha256:d8853d1c1b7322b8b7e3bab730fccd0652c0c97a825c3317b3bc705d650f5c5f",
    "public_key": "ro3Bpht0HXDL35PmxRYoDKMwaeX3rlBcCqCYszHaW20=",
    "public_key_pem": "-----BEGIN PUBLIC KEY-----\n…\n-----END PUBLIC KEY-----\n",
    "published_status": "active",
    "published_detail": "Es la clave vigente publicada por Blockgence (desde 2026-11-13)."
  },
  "configured_note": null,
  "published": {
    "algorithm": "ed25519",
    "web": {
      "es": "https://www.blockgence.com/verificar.html",
      "en": "https://www.blockgence.com/en/verify.html"
    },
    "active_key_id": "sha256:d8853d1c1b7322b8b7e3bab730fccd0652c0c97a825c3317b3bc705d650f5c5f",
    "keys": [{
      "key_id": "sha256:d8853d1c1b7322b8b7e3bab730fccd0652c0c97a825c3317b3bc705d650f5c5f",
      "status": "active",
      "valid_from": "2026-11-13",
      "valid_until": null,
      "revoked_at": null,
      "…": "…"
    }]
  },
  "matches_published": true,
  "signed_message": "blockgence-integrity-v1:sha256:<digest en hex>",
  "proves": "…",
  "does_not_prove": "…",
  "verify": ["…"]
}
```

The response can be cached for 5 minutes. Its text fields are in Spanish.

## Key states

| State | What it means | Does what it signed still count? |
| - | - | - |
| `active` | The current one. There is only one. | Yes. |
| `retired` | Replaced without being compromised. | Yes, what was signed between `valid_from` and `valid_until`. |
| `revoked` | Compromised, or suspected to be. | **No**, not even what is dated before `revoked_at`. |

> [!WARNING]
>
> A revoked key also invalidates documents dated before the revocation. A document's date (`manifest.generated_at`) is set by the same system that signs, and whoever holds the key can date it however they want.

## If the key changes

* **Rotation:** the new key shows up as current and the previous one moves to the retired list, with its period. Documents signed with the previous key during its period remain valid.
* **Compromise:** the key moves to revoked, with the date and the reason, and a new one is generated.

In both cases the three channels change at once: the website (with its date), the API and this page.

> [!NOTE]
>
> **Retired and revoked keys: none so far.**


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.