---
title: "Credentials API: Issue, Verify, Status"
description: "The HTTP surface of the OpenEPCIS credential issuer and verifier on epc.is, with curl examples for the DID document, OID4VCI metadata, issuance, public retrieval, verification, status lists, the trusted issuer list, audit checkpoints and tier unlock at the resolver."
canonical_url: "https://openepcis.io/docs/digital-product-passport/credentials-api"
last_updated: "2026-11-18T23:35:32.531Z"
---

The credential service on epc.is answers at `https://issuer.epc.is`. The GS1
Digital Link resolver answers at `https://id.epc.is`. Read endpoints are
anonymous. Issuing and revoking need a bearer token of your tenant.

[Signed Passports](/docs/digital-product-passport/signed-passports) explains the
concepts behind each call and lists which parts are available, released or in
preparation.

## Endpoints at a glance

<table>
<thead>
  <tr>
    <th>
      Method
    </th>
    
    <th>
      Path
    </th>
    
    <th>
      Access
    </th>
    
    <th>
      Purpose
    </th>
  </tr>
</thead>

<tbody>
  <tr>
    <td>
      <code>
        GET
      </code>
    </td>
    
    <td>
      <code>
        /.well-known/did.json
      </code>
    </td>
    
    <td>
      public
    </td>
    
    <td>
      Issuer DID document with the verification key
    </td>
  </tr>
  
  <tr>
    <td>
      <code>
        GET
      </code>
    </td>
    
    <td>
      <code>
        /.well-known/openid-credential-issuer
      </code>
    </td>
    
    <td>
      public
    </td>
    
    <td>
      OID4VCI issuer metadata
    </td>
  </tr>
  
  <tr>
    <td>
      <code>
        POST
      </code>
    </td>
    
    <td>
      <code>
        /vc/oid4vci/credential
      </code>
    </td>
    
    <td>
      bearer
    </td>
    
    <td>
      OID4VCI credential endpoint for wallets
    </td>
  </tr>
  
  <tr>
    <td>
      <code>
        POST
      </code>
    </td>
    
    <td>
      <code>
        /vc/credentials/{configId}
      </code>
    </td>
    
    <td>
      bearer
    </td>
    
    <td>
      Administrative issuance
    </td>
  </tr>
  
  <tr>
    <td>
      <code>
        GET
      </code>
    </td>
    
    <td>
      <code>
        /vc/credentials/{credentialId}
      </code>
    </td>
    
    <td>
      public
    </td>
    
    <td>
      Signed bytes of a Public credential
    </td>
  </tr>
  
  <tr>
    <td>
      <code>
        POST
      </code>
    </td>
    
    <td>
      <code>
        /vc/credentials/{credentialId}/revoke
      </code>
    </td>
    
    <td>
      bearer
    </td>
    
    <td>
      Permanent revocation
    </td>
  </tr>
  
  <tr>
    <td>
      <code>
        GET
      </code>
    </td>
    
    <td>
      <code>
        /vc/status/{listId}
      </code>
    </td>
    
    <td>
      public
    </td>
    
    <td>
      Status list credential or token
    </td>
  </tr>
  
  <tr>
    <td>
      <code>
        POST
      </code>
    </td>
    
    <td>
      <code>
        /vc/verify?profile=
      </code>
    </td>
    
    <td>
      public
    </td>
    
    <td>
      Layered verification
    </td>
  </tr>
  
  <tr>
    <td>
      <code>
        GET
      </code>
    </td>
    
    <td>
      <code>
        /.well-known/vc-trusted-issuers[/{tenant}]
      </code>
    </td>
    
    <td>
      public
    </td>
    
    <td>
      Signed trusted issuer list (released, not yet on epc.is)
    </td>
  </tr>
  
  <tr>
    <td>
      <code>
        GET
      </code>
    </td>
    
    <td>
      <code>
        /.well-known/audit-checkpoints/{tenant}
      </code>
    </td>
    
    <td>
      public
    </td>
    
    <td>
      Sealed audit checkpoints (released, not yet on epc.is)
    </td>
  </tr>
  
  <tr>
    <td>
      <code>
        GET
      </code>
    </td>
    
    <td>
      <code>
        /vc/oid4vp/request/{sessionId}
      </code>
    </td>
    
    <td>
      wallet
    </td>
    
    <td>
      Signed OID4VP request object (released, not yet on epc.is)
    </td>
  </tr>
  
  <tr>
    <td>
      <code>
        POST
      </code>
    </td>
    
    <td>
      <code>
        /vc/oid4vp/response/{sessionId}
      </code>
    </td>
    
    <td>
      wallet
    </td>
    
    <td>
      OID4VP response, <code>
        direct_post.jwt
      </code>
      
       (released, not yet on epc.is)
    </td>
  </tr>
</tbody>
</table>

Errors carry a body that names the reason. A 422 means the request was well
formed but the data cannot be signed or found; a 502 means an upstream service
failed.

## DID document

```bash
curl -s https://issuer.epc.is/.well-known/did.json
```

```json
{
  "@context": ["https://www.w3.org/ns/did/v1", "https://w3id.org/security/suites/jws-2020/v1"],
  "id": "did:web:issuer.epc.is",
  "verificationMethod": [{
    "id": "did:web:issuer.epc.is#key-2026-08",
    "type": "JsonWebKey2020",
    "controller": "did:web:issuer.epc.is",
    "publicKeyJwk": { "kty": "EC", "crv": "P-256", "x": "k_8Ex-ND…", "y": "x0o5pWPY…" }
  }],
  "assertionMethod": ["did:web:issuer.epc.is#key-2026-08"]
}
```

Every artefact the issuer signs names this method in its `kid` or
`verificationMethod`. Keep a copy if you want to verify offline later.

## Issuer metadata and credential configurations

```bash
curl -s https://issuer.epc.is/.well-known/openid-credential-issuer
```

The document names the credential endpoint, the authorisation server
(`https://auth.epc.is/realms/platform`) and every credential configuration with
its OID4VCI format:

<table>
<thead>
  <tr>
    <th>
      Configuration
    </th>
    
    <th>
      Format
    </th>
    
    <th>
      Type
    </th>
  </tr>
</thead>

<tbody>
  <tr>
    <td>
      <code>
        dpp-battery
      </code>
      
      , <code>
        dpp-textile
      </code>
      
      , <code>
        dpp-electronics
      </code>
      
      , <code>
        dpp-eudr
      </code>
      
      , <code>
        dpp-cpr
      </code>
      
      , <code>
        dpp-ppwr
      </code>
      
      , <code>
        dpp-iron-steel
      </code>
      
      , <code>
        dpp-detergent
      </code>
      
      , <code>
        dpp-fsma204
      </code>
    </td>
    
    <td>
      <code>
        ldp_vc
      </code>
    </td>
    
    <td>
      <code>
        oec:DigitalProductPassport
      </code>
    </td>
  </tr>
  
  <tr>
    <td>
      <code>
        dpp-battery-tiered
      </code>
    </td>
    
    <td>
      <code>
        jwt_vc_json
      </code>
    </td>
    
    <td>
      <code>
        oec:DigitalProductPassport
      </code>
      
      , one credential per access tier
    </td>
  </tr>
  
  <tr>
    <td>
      <code>
        org-identity
      </code>
    </td>
    
    <td>
      <code>
        ldp_vc
      </code>
    </td>
    
    <td>
      <code>
        DigitalIdentityAnchor
      </code>
      
       (UNTP), revocable
    </td>
  </tr>
  
  <tr>
    <td>
      <code>
        epcis-event
      </code>
    </td>
    
    <td>
      <code>
        ldp_vc
      </code>
    </td>
    
    <td>
      EPCIS event credential, subject by reference with the CBV event hash
    </td>
  </tr>
</tbody>
</table>

To list the configuration ids:

```bash
curl -s https://issuer.epc.is/.well-known/openid-credential-issuer \
  | python3 -c 'import json,sys; print("\n".join(json.load(sys.stdin)["credential_configurations_supported"]))'
```

## Issuing a credential

Issuance needs an access token of your tenant from the epc.is Keycloak realm.
[API Reference: Authenticating](/docs/api-reference#authenticating) shows how to
get a session token or a long-lived offline token.

For a passport, the subject is the full GS1 Digital Link URI of the product.
The host must be a platform host or a verified
[resolver domain](/docs/digital-data-management/resolver-domains) of your tenant.

**From a wallet (OID4VCI).** Field names follow the specification:

```bash
curl -s -X POST https://issuer.epc.is/vc/oid4vci/credential \
  -H "Authorization: Bearer $TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
        "credential_configuration_id": "dpp-battery",
        "subject_id": "https://id.epc.is/01/09521002005004"
      }'
```

```json
{ "credential": "<the signed credential>" }
```

A request with a `proof` is refused with `invalid_proof`: this issuer does not
bind credentials to a holder key. Errors use the OAuth shape
`{"error": "...", "error_description": "..."}`.

**From an integration (administrative).** Same pipeline, with the stored
credential id and media type in the answer:

```bash
curl -s -X POST https://issuer.epc.is/vc/credentials/dpp-battery \
  -H "Authorization: Bearer $TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{ "subjectId": "https://id.epc.is/01/09521002005004" }'
```

```json
{
  "credentialId": "urn:uuid:…",
  "format": "VC_LD_DATA_INTEGRITY",
  "mediaType": "application/vc+ld+json",
  "credential": "…",
  "slices": null
}
```

For `dpp-battery-tiered`, `slices` lists the credential per access tier.

<table>
<thead>
  <tr>
    <th>
      Status
    </th>
    
    <th>
      Meaning
    </th>
  </tr>
</thead>

<tbody>
  <tr>
    <td>
      200
    </td>
    
    <td>
      Issued
    </td>
  </tr>
  
  <tr>
    <td>
      403
    </td>
    
    <td>
      The token names no tenant, or the subject host is not yours (reason in the body)
    </td>
  </tr>
  
  <tr>
    <td>
      404
    </td>
    
    <td>
      Unknown configuration id
    </td>
  </tr>
  
  <tr>
    <td>
      422
    </td>
    
    <td>
      The subject source has no such record, or the credential would not be verifiable elsewhere
    </td>
  </tr>
  
  <tr>
    <td>
      503
    </td>
    
    <td>
      Issuance is disabled on this instance (no signing key)
    </td>
  </tr>
</tbody>
</table>

## Retrieving a credential

Public credentials are dereferenceable without authentication. The answer is
the stored signed artefact under its media type, never a re-rendering:

```bash
curl -s https://issuer.epc.is/vc/credentials/<credentialId>
```

Credentials above the Public tier answer 404 here.

## Revoking a credential

```bash
curl -s -X POST https://issuer.epc.is/vc/credentials/<credentialId>/revoke \
  -H "Authorization: Bearer $TOKEN"
```

```json
{ "credentialId": "urn:uuid:…", "revoked": true, "error": null }
```

Revocation is permanent and idempotent. A credential issued without a status
slot answers 409, and a credential of another tenant answers 404.

## Status lists

The `credentialStatus` entry of a revocable credential points at its list:

```bash
curl -s -D - https://issuer.epc.is/vc/status/<listId>
```

The list is served anonymously as `application/vc+jwt` (W3C Bitstring Status
List) or `application/statuslist+jwt` (IETF Token Status List), with
`Cache-Control: public, max-age=300`.

## Verifying a credential

Pass the credential as a string (compact JWS, SD-JWT, JSON-LD text) or as a
JSON-LD object. The `profile` parameter selects the policy: `self` (default),
`untp`, `gs1` or `espr-authority`. This example fetches a Data Integrity
credential and posts it as an object:

```bash
curl -s https://issuer.epc.is/vc/credentials/<credentialId> \
  | python3 -c 'import json,sys; print(json.dumps({"credential": json.load(sys.stdin)}))' \
  | curl -s -X POST 'https://issuer.epc.is/vc/verify?profile=self' \
      -H 'Content-Type: application/json' --data @-
```

```json
{
  "valid": true,
  "errors": [],
  "issuer": "did:web:issuer.epc.is",
  "verificationMethod": "did:web:issuer.epc.is#key-2026-08",
  "policy": "self",
  "stages": {
    "ENVELOPE": "PASS",
    "PROOF": "PASS",
    "CONTROLLER_BINDING": "PASS",
    "VALIDITY": "PASS",
    "STATUS": "NOT_APPLICABLE",
    "TRUST_ROOT": "NOT_APPLICABLE",
    "AUTHORITY": "NOT_APPLICABLE"
  },
  "assurance": "NONE"
}
```

`valid` is the policy decision; `stages` keeps "signature valid but revoked"
apart from "issuer unknown". A missing body answers 400 with the expected shape,
and an unknown profile answers 400 with the list of profiles.

You do not have to trust our verifier. Any Data Integrity verifier that resolves
`did:web` can check the same credential, because the DID document and the
contexts are public.

## Trusted issuer list

Released, not yet answered by `issuer.epc.is`. The call is:

```bash
curl -s https://issuer.epc.is/.well-known/vc-trusted-issuers
curl -s https://issuer.epc.is/.well-known/vc-trusted-issuers/<tenant>
```

The answer is `application/jwt`, a compact JWS with `typ: trusted-issuers+jwt`.
To read the payload:

```bash
curl -s https://issuer.epc.is/.well-known/vc-trusted-issuers \
  | python3 -c 'import sys,base64,json; p=sys.stdin.read().split(".")[1]; print(json.dumps(json.loads(base64.urlsafe_b64decode(p+"="*(-len(p)%4))),indent=2))'
```

```json
{
  "iss": "did:web:issuer.epc.is",
  "iat": 1792707756,
  "exp": 1792711356,
  "ver": 1792707756954,
  "issuers": [
    { "id": "did:web:issuer.partner.example", "kind": "did", "tenant": "…",
      "scopes": ["https://id.gs1.org/01/0401234"], "status": "active" }
  ]
}
```

Check the signature against the key in `did.json` whose id equals the header
`kid`, reject an expired list, and refuse a `ver` lower than one you have seen.
An unknown tenant receives a valid, empty list.

## Audit checkpoints

Released, not yet answered by `issuer.epc.is`. The tenant is a chain key:
`gln-<GLN13>`, `grp-<tenant group>` or `platform`.

```bash
curl -s https://issuer.epc.is/.well-known/audit-checkpoints/gln-<GLN13>
```

```json
{ "tenant": "gln-…", "checkpoints": ["<jws>", "<jws>"] }
```

Each checkpoint decodes to a payload like this:

```json
{
  "tenant": "grp-…",
  "seq": 878,
  "head": "f4888da4700b4a43c15df2e3bf79e1228140f886038ccea0c2bfa57f746e2377",
  "issuedAt": "2026-10-22T18:05:07.998Z",
  "kid": "did:web:issuer.epc.is#key-2026-08",
  "iss": "did:web:issuer.epc.is"
}
```

A seal verifies against `did.json`. With an export of the entries from your
tenant you can recompute each `hash = sha256(JCS(entry without hash))`, follow
`prevHash` from the genesis (64 zeros), and confirm the chain reaches every
sealed `head`.

## Unlocking a tier at the resolver

In preparation on epc.is: the resolver and the verifier implement the flow, and
it stays off until the credential-type-to-role mapping is configured. The calls
look like this.

Ask for a tier on a single-record read:

```bash
curl -s -D - -H 'DPP-Tier: Restricted' \
  'https://id.epc.is/01/09521002005004?linkType=masterData'
```

If you do not reach the tier, the resolver answers with two challenges:

```text
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer realm="openepcis", error="insufficient_tier", tier="Restricted",
                  OID4VP request_uri="https://issuer.epc.is/vc/oid4vp/request/3f1c…", session="3f1c…"
Content-Type: application/problem+json
```

Hand the `request_uri` to the wallet. A client without a wallet back channel
polls the session at the resolver until `status` is `verified`, `failed` or
`expired`:

```bash
curl -s https://id.epc.is/access/sessions/3f1c…
```

```json
{ "status": "verified", "receipt": "<jws>" }
```

Repeat the read with the receipt:

```bash
curl -s -H "DPP-Receipt: $RECEIPT" -H 'DPP-Tier: Restricted' \
  'https://id.epc.is/01/09521002005004?linkType=masterData'
```

The receipt is valid for at most 15 minutes and only once per resolver
instance. A receipt bound to another resource answers 403
`insufficient_scope`; an invalid one answers 401 `invalid_token` with the reason
in `error_description`. A receipt grants read access only.

## Related pages

- [Signed Passports](/docs/digital-product-passport/signed-passports): concepts
and availability
- [API Reference](/docs/api-reference): the OpenAPI references for the resolver
and the EPCIS repository
- [Integration Tokens](/docs/digital-data-management/connector-tokens):
long-lived tokens for unattended issuance
