arrow-left

All pages
gitbookPowered by GitBook
1 of 6

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Set Up Your Account

Follow these steps to create your account on cheqd Studio and begin using our APIs securely.

The user is required to Log In to our cheqd Studio portal and then access their API key to authenticate with our APIs. The API key guards the API from unauthorized access and is required for both testing production environments.

hashtag
Step 1: Get started with cheqd Studio

Head to our cheqd Studio and click Get Started.

hashtag
Step 2: Create your account

cheqd Studio uses a to handle user authentication and login. You can create an account or sign in using:

  • Email and password

  • Google single sign-on

  • Discord login

Click Sign In or Create Account to continue.

hashtag
Step 3: Create a new API key and authenticate with cheqd Studio APIs

Once signed in, create an API key from your account dashboard. This key is required to authenticate with cheqd Studio APIs and protects your environment from unauthorized access.

hashtag
Step 4: Start using cheqd

Get started with our tutorials for cheqd Studio functionality.

hashtag
Step 5: Select a Billing plan

You will be able to get started for free on our free trial, but following the expiry of the free trial, users need to sign up for a paid billing plan. cheqd Studio billing uses as a payments processor and users will need to input their card information to initiate a billing plan.

third party service called LogToarrow-up-right
Stripearrow-up-right

cheqd Studio

Click here to sign up for a cheqd Studio plan to get started with creating API keys.

Sign into your account
Create a new account

API keys

Create a new API key to authenticate with the cheqd Studio APIs.

DIDs and Identity Keys

Create did:cheqd DIDs for credential issuers and for DID-Linked Resources

Trust Registries

Create an end-to-end trusted ecosystem, using Trust Chains to build a full Trust Registry.

Payments

Create commercial models for verifiable credentials, such as verifier-pays-issuer

Status Lists

Create status lists, including Status List v2021 and Token Status List

Credentials

Issue any type of credential, including SD-JWT, VCDM and AnonCreds via our partners, including trust registries, status lists and payments.

Resources

Create custom resources for policies, presentation definitions, schemas and visual representations of credentials

Create API Keys

Generate API Keys to securely authenticate with cheqd Studio APIs.

API keys are unique data strings used to authenticate a user and enable access to privileged operations on cheqd Studio APIs. All cheqd Studio APIs use API keys as the mechanism to authenticate client requests. Your API key should be kept confidential and secure at all times.

  • Authentication is required for all API requests; without it, the requests will fail.

  • All API requests must be made over HTTPS.

circle-info

hashtag
🚧Keep Your API Keys Safe

Because our API keys allow access to cheqd Studio APIs, you must keep them secure at all times.

  • Ensure your API key is always stored securely as soon as it is initially generated.

  • Make sure to copy your API key into a secure place, such as a Password Manager.

hashtag
Step 1: Sign into cheqd Studio

Follow the tutorial here to get started with your cheqd Studio account.

hashtag
Step 2: Generate API key

Navigate to the "Developers" tab on cheqd Studio and select "Create an API Key". You are able to choose the expiry date of the API key, and it will automatically be set to expire 1 year from the current date.

hashtag
Step 3: Use your API key to authenticate with cheqd Studio APIs

Navigate to the "APIs" tab and copy/paste your API key into the API key box towards the top of your page. This will enable you to authenticate with the cheqd Studio APIs, allowing users to use cheqd Studio APIs within their existing Billing Plan and usage limits.

hashtag
Step 4: Start using cheqd

Get started with our tutorials for cheqd Studio functionality.

Never share it or record it in a publicly accessible medium (client-side code, public repositories, etc.).

Caution: If you lose secure control of your API keys, your entity may not be able to access your created DIDs, DID-Linked Resources or Credential Payments.

Set up your account

Get started with cheqd Studio, setting up your account and selecting a Billing Plan.

DIDs and Identity Keys

Create did:cheqd DIDs for credential issuers and for DID-Linked Resources

Trust Registries

Create an end-to-end trusted ecosystem, using Trust Chains to build a full Trust Registry.

Payments

Create commercial models for verifiable credentials, such as verifier-pays-issuer

Status Lists

Create status lists, including Bitstring Status List and Token Status List

Credentials

Issue any type of credential, including SD-JWT, VCDM and AnonCreds via our partners, including trust registries, status lists and payments.

Resources

Create custom resources for policies, presentation definitions, schemas and visual representations of credentials

Token Top Up

Manually Top Up Your Account with CHEQ.

Users may exhaust their usage limits in their cheqd Studio billing plan, but may want to continue using the Studio before their usage limits refresh. Therefore, users can manually top up their account with CHEQ tokens to use any APIs that involve a ledger-write, e.g:

  1. Creating, Updating or Deactivating DIDs

  2. Creating unencrypted or encrypted Status Lists

  3. Creating Trust Registries

  4. Creating other DID-Linked Resources

hashtag
Step 1: Locate your cheqd address (for CHEQ)

The following API can be used to fetch the new account information:

  • customer_id is used as an identifier for the particular customer using cheqd Studio. It is generated as a sub-field of the JWT token used in the authorization header.

  • cheqd_account is used to pay for identity transactions on either testnet or mainnet. A cheqd account is automatically generated when a new customer_id is generated.

hashtag
Step 2: Adding CHEQ tokens to your account

If you exceed the usage limits in your cheqd Studio billing plan but want to continue using ledger-based functionality before your limits reset, you can manually top up your account using CHEQ tokens.

If you need to add CHEQ tokens to your cheqd Studio cheqd_account, there are a few steps you need to follow:

chevron-rightMainnethashtag
  • First you need to which is able to hold CHEQ tokens. We recommend using which natively supports all CHEQ transactions in a browser plugin or on mobile. Alternatively, follow the .

  • You will then need to .

chevron-rightTestnethashtag
  • It is unlikely that you will ever need to top up your Testnet account, as this is handled automatically. However, in the event that your Testnet account runs out of tokens, you can follow the step below.

  • This is super simple. You can add free CHEQ tokens to your cheqd_account by inputting your cheqd account address. Access the .

Once you have successfully created an account and have topped up your CHEQ tokens, you are ready to get started!

hashtag
Step 3: Continue using cheqd

Get started with our tutorials for cheqd Studio functionality.

Advanced Configuration Options

Advanced setup guide for running the cheqd Studio.

hashtag
Run as standalone application using Docker Compose

If you want to run the application without any external databases or dependent services, we provide a Docker Compose filearrow-up-right to spin up a standalone service.

This standalone service uses an in-memory database with no persistence, and therefore is recommended only if you're managing key/secret storage separately.

The in the same folder contains all the environment variables necessary to configure the service. (See section Configuration above.)

hashtag
Run with external Key Management System (KMS) and/or authentication service using Docker Compose

Construct the postgres URL and configure the env variables mentioned above.

Spinning up a Docker container from the is as simple as the command below:

hashtag
Configure PostgreSQL database

Configure the environment variables in the :

  1. POSTGRES_USER: Username for Postgres database

  2. POSTGRES_PASSWORD: Password for Postgres database

  3. POSTGRES_MULTIPLE_DATABASES

Then, make the Postgres initialisation scripts executable:

hashtag
Start LogTo service

Configure the environment variables in the with the settings described in section above.

Then, run the LogTo service to configure the LogTo application API resources, applications, sign-in experiences, roles etc using Docker Compose:

Configuring LogTo is outside the scope of this guide, and we recommend reading to familiarise yourself.

hashtag
Start credential-service app

Configure the environment variables in the with the settings described in section above. Depending on whether you are using external Veramo KMS only, LogTo only, or both you will need to have previously provisioned these services as there are environment variables in this file that originate from Postgres/LogTo.

Then, start the service using Docker Compose:

hashtag
Running app or LogTo migrations

When upgrading either the external Veramo KMS or LogTo, you might need to run migrations for the underlying databases.

You can run just the migration scripts using defined in the Compose file.

For example, to run cheqd Studio app migrations on an existing Postgres database (for external Veramo KMS):

Or to run LogTo migrations on an existing Postgres database:

hashtag
Build using Docker

To build your own image using Docker, use the provided.

Changelog

Chronological changelog for cheqd Studio portal releases.

hashtag
Release 7: Manage and verify Credentials (07/11/2025)

hashtag
Features

  • Credential history Updates and Credential Details

  • verify Credentials: both JWT and JSON-LD using file uploads and simple paste.

hashtag
Bug Fixes

  • Add expiry status in Credential Details Page

  • error handling for jsonld credential verification

  • minor ui bugs and test provider

hashtag
Release 6: Issue Credential and support external providers (21/10/2025)

hashtag
Features

  • Add Download Credential & Supported Providers env

  • Add Credential issuance using cheqd Studio

  • Support for JWT and JSON-LD credentials

hashtag
Bug Fixes

  • Add email validation in credenitals

  • Adjusted responsiveness and min-max widths + more conservative resolution parallelisation limit

  • Augmented state handling + interactive management

hashtag
Performance Improvements

  • Integrate did metadata api


hashtag
Release 5: Optimisations and State management improvement (12/09/2025)

hashtag
Features

  • Display Resource Versions & UI improvements

hashtag
Bug Fixes

  • Apply member filters in server

  • Create resource operation

  • Improved state management & fixes in list operations


hashtag
Release 4: Add support for Organizations and Agents (09/09/2025)

hashtag
Features

  • Update Service section to support did name, type fields

  • Add organizations and agents as default options for identifiers

hashtag
Bug Fixes

  • Url validations & Create DID form fixes


hashtag
Release 3: Add support for Trust Ecosystems (03/09/2025)

hashtag
Features

  • Support Trust ecosystems in UI, including accreditations for members in the ecosystem

  • Add authorization for specific schemas for members of ecosystems

hashtag
Bug Fixes

  • Release versioning + v1.7.1 beta


hashtag
Release 2: Add DID-Linked Resources in UI (21/08/2025)

hashtag
Features

  • Add create Resource underneath DIDs in UI

  • Optimize data rendering in create-resource

  • Add new Settings Tabs

hashtag
Bug Fixes

  • nav bar update

  • Remove usdc prices


hashtag
Release 1: Add new dashboard for cheqd Studio metrics (13/08/2025)

hashtag
Features

  • Add features for Dashboard and Api access in portal

  • Add create DID option in UI

  • Improve UI for managing API keys

docker compose -f docker/no-external-db/docker-compose-no-db.yml up --detach
Begin integration of dock issuance & credential history
  • Create new page for issuance providers

  • Update schema type to array & Add member did validations

  • Validate Verification methods for Dock

  • Client-side favourable DID state management + table sorting
  • did dropdowns with consistent naming & schema handling in members

  • disable trust validation and tracking

  • fix expiry date not appearing correctly

  • encoded resourceName handling

  • error message on credential issue failure

  • Fix ecosystems state update

  • invalid did value passed in dropdown

  • Minor UI improvements

  • Pagination and enable Dock provider

  • resizing and assertionMethod toggle

  • significant improvement to session handling

  • Ui state management improvments

  • Replace Buffer with Uint8arrays
    User menu changes

    You will need to send CHEQ tokens from your new cheqd Wallet account to your cheqd_account address for using the Credential Service.

    setup your wallet
    Leap Walletarrow-up-right
    tutorial here to setup your Keplr wallet
    get CHEQ tokens from any of the listed providers herearrow-up-right
    via our Testnet Faucet
    Testnet Faucet directly herearrow-up-right

    DIDs and Identity Keys

    Create did:cheqd DIDs for credential issuers and for DID-Linked Resources

    Trust Registries

    Create an end-to-end trusted ecosystem, using Trust Chains to build a full Trust Registry.

    Payments

    Create commercial models for verifiable credentials, such as verifier-pays-issuer

    Status Lists

    Create status lists, including Status List v2021 and Token Status List

    Credentials

    Issue any type of credential, including SD-JWT, VCDM and AnonCreds via our partners, including trust registries, status lists and payments.

    Resources

    Create custom resources for policies, presentation definitions, schemas and visual representations of credentials

    : Database names for multiple databases in the same cluster, e.g.:
    "app,logto"
    . This sets up multiple databases in the same cluster, which can be used independently for External Veramo KMS or LogTo service.
    no-db.env filearrow-up-right
    pre-built cheqd Studio Docker image on Githubarrow-up-right
    logto.env filearrow-up-right
    LogTo documentationarrow-up-right
    with-db.env filearrow-up-right
    Docker Compose profilesarrow-up-right
    Dockerfilearrow-up-right
    chmod +x docker/with-external-db/pg-init-scripts/create-multiple-postgresql-databases.sh
    docker compose -f docker/with-external-db/docker-compose-with-db.yml --profile logto up --detach
    docker compose -f docker/with-external-db/docker-compose-with-db.yml up --detach
    docker compose -f docker/with-external-db/docker-compose-with-db.yml --profile app-setup up --detach
    docker compose -f docker/with-external-db/docker-compose-with-db.yml --profile logto-setup up --detach
    docker build --file docker/Dockerfile --target runner . --tag credential-service:local

    Get Started with cheqd Studio

    Get started with cheqd's API product offering for creating DIDs, trust registries and monetising credentials: cheqd Studio.

    hashtag
    Introduction

    cheqd Studio is a set of APIs, guides and tutorials to help users establish an end-to-end trusted ecosystem for digital credentials.

    Using REST APIs, customers can build cheqd's trust infrastructure into existing applications. All of cheqd’s existing open-source libraries remain available, and cheqd Studio does not necessitate developers to switch their SSI stack in their entirety, but allows them to build into their existing tooling, for example alongside APIs such as the Universal Resolver.

    hashtag
    Get started

    hashtag
    Features

    cheqd Studio directly leverages our , making a wide array of features available from launch, including:

    hashtag
    Understanding the different modes and client choices

    With cheqd Studio, there are multiple ways it can be deployed and hosted to support clients with different requirements.

    hashtag
    Option 1: Custodied by cheqd (Custodian Mode)

    This mode is the most simple for users, allowing cheqd to custody both Cosmos AND Identity keys in Veramo KMS. This means that manages both ledger-writes and signing identity transactions on behalf of the customer.

    To ensure this is highly secure, we have deployed an instance of a Veramo Key Management Store (KMS) which uses a Postgress DB (TypeOrm) to store Cosmos AND identity keys in one encrypted table, so it cannot be read in plaintext. This design allows us to segment different customers' keys securely and efficiently.

    We use similar techniques to Password Managers such as and to ensure that even if the database were to be compromised, the keys would remain encrypted and unusable.

    hashtag
    User optionality and toggles:

    Within Custodian mode, we also enable clients to toggle

    chevron-rightExternal Databasehashtag

    Clients are able to choose whether to use our default database for storing keys or utilise their own database.

    By default, ENABLE_EXTERNAL_DB is set to off/false. To enable external Veramo KMS database, set ENABLE_EXTERNAL_DB to true

    chevron-rightAPI Authentication using LogTohashtag

    By default, the application has API authentication disabled (which can be changed in configuration). If, however, you'd like to run the app with API authentication features, the following variables need to be configured.

    We use a self-hosted version of , which supports OpenID Connect. Theoretically, these values could also be replaced with or any other OpenID Connect identity provider.

    By default, ENABLE_AUTHENTICATION is set to off/false

    hashtag
    Option 2: Self-custodied (Client-managed mode)

    Client-managed mode gives the cheqd Studio user the ability to utilise their own identity keys for signing identity transactions, while still allowing cheqd Studio to manage the CHEQ account keys for writing to the cheqd network. This mode is intended to be used for more production environments where the user signs each identity transaction independently, affording a greater level of security and control to the client.

    circle-info

    Full client-managed mode is still in development and we will update this documentation as and when it becomes available

    hashtag
    Architecture

    Under the hood, cheqd Studio leverages our for its identity functionality. Check out our to understand how cheqd Studio fits together with our other Open Source packages.

    hashtag
    Alternative: Use an SDK

    If you would rather a deeper integration with lower-level packages, instead of REST APIs, take a look at our suite of cheqd supported SDKs below. Each offers a different set of protocols and underlying technical capabilities.

    , then define below environment variables in
    .env
    file:
    1. EXTERNAL_DB_CONNECTION_URL: PostgreSQL database connection URL, e.g. postgres://<user>:<password>@<host>:<port>/<database>.

    2. EXTERNAL_DB_ENCRYPTION_KEY: Secret key used to encrypt the Veramo key-specific database tables. This adds a layer of protection by not storing the database in plaintext.

    3. EXTERNAL_DB_CERTIFICATE: Custom CA certificate required to connect to the database (optional).

    . To enable external Veramo KMS database, set
    ENABLE_AUTHENTICATION
    to
    true
    , then define below environment variables in
    .env
    file:
    1. Endpoints

      1. LOGTO_ENDPOINT: API endpoint for LogTo server

      2. LOGTO_DEFAULT_RESOURCE_URL: Root of API resources in this application to be guarded. (Default: http://localhost:3000/api on localhost.)

      3. LOGTO_MANAGEMENT_API: URL of management API for LogTo (default is https://default.logto.app/api)

      4. CORS_ALLOWED_ORIGINS: CORS allowed origins used in the app

    2. User-facing APIs

      1. LOGTO_APP_ID: Application ID for the cheqd Studio application in LogTo. This can be set up as type "Traditional Web"

      2. LOGTO_APP_SECRET: Application secret associated with App ID above.

    3. Machine-to-machine backend APIs

      1. LOGTO_M2M_APP_ID: Application ID for machine-to-machine application in LogTo. This is used for elevated management APIs within LogTo.

      2. LOGTO_M2M_APP_SECRET

    4. Default role update using : LogTo supports webhooks to fire of requests to an API when it detects certain actions/changes. If you want to automatically assign a role to users, a webhook is recommended to be setup for firing off whenever there's a new account created, or a new sign-in.

      1. LOGTO_DEFAULT_ROLE_ID: LogTo Role ID for the default role to put new users into.

    5. Miscellaneous

      1. DEFAULT_CUSTOMER_ID: Customer/user in LogTo to use for unauthenticated users

      2. COOKIE_SECRET: Secret for cookie encryption.

    Veramo SDK Pluginarrow-up-right
    1Passwordarrow-up-right
    Bitwardenarrow-up-right
    LogToarrow-up-right
    LogTo Cloudarrow-up-right
    Veramo SDK Pluginarrow-up-right
    guide on supported SDKs

    Set Up Your Account

    Begin your cheqd Studio set up, creating your account, creating an API key and authenticating with our APIs.

    Create an API Key

    Create your first API Key and authenticate with the cheqd Studio APIs to begin using the identity functionality.

    Advanced Configuration Options

    Run cheqd Studio yourself or use your own external database.

    DIDs and Identity Keys

    Create did:cheqd DIDs for credential issuers and for DID-Linked Resources.

    Trust Registries

    Create an end-to-end trusted ecosystem, using Trust Chains to build a full Trust Registry.

    Payments

    Create commercial models for verifiable credentials, such as verifier-pays-issuer.

    Status Lists

    Create status lists, including Bitstring Status List and Token Status List.

    Verifiable Credentials

    Issue any type of credential, including SD-JWT, VCDM and AnonCreds via our partners, including trust registries, status lists and payments.

    DID-Linked Resources

    Create custom resources for policies, presentation definitions, schemas and visual representations of credentials.

    Cover

    Credo

    Credo is an SDK that is building directly towards supporting the EUDI standards, as well as support for AnonCreds.

    Cover

    ACA-Py

    ACA-Py is a quickly expanding SDK, moving from the AnonCreds ecosystem towards wider support for EUDI.

    Cover

    Veramo

    The Veramo SDK Plugin is an extension of the Veramo SDK, a JavaScript framework for Trusted Data, adding support for cheqd functionality.

    Cover

    Walt.id Community Stack

    Walt.id Community Stack is an SDK that supports the standards for identity, with cheqd DID support.

    : Application secret
    LOGTO_WEBHOOK_SECRET
    : Webhook secret to authenticate incoming webhook requests from LogTo.
    LogTo webhooksarrow-up-right
    European Architecture and Reference Framework (ARF)arrow-up-right
    postgres.env fileenvelope

    hashtag
    Fetch custodian-mode client details.

    get
    /account

    This endpoint returns the custodian-mode client details for authenticated users.

    Authorizations
    x-api-keystringRequired
    Responses
    chevron-right
    200

    The request was successful.

    application/json
    chevron-right
    400

    A problem with the input fields has occurred. Additional state information plus metadata may be available in the response body.

    chevron-right
    401

    Access token is missing or invalid

    chevron-right
    500

    An internal error has occurred. Additional state information plus metadata may be available in the response body.

    get
    /account
    {
      "customer": {
        "customerId": "text",
        "name": "text"
      },
      "paymentAccount": {
        "mainnet": "text",
        "testnet": "text"
      }
    }
    GET /account HTTP/1.1
    Host: studio-api.cheqd.net
    x-api-key: YOUR_API_KEY
    Accept: */*