1Kosmos · Verifiable Credentials

Verifiable Credentials API

Issue and verify W3C verifiable credentials, held by the user.

The Verifiable Credentials Service issues, stores and verifies W3C-standard verifiable credentials. Define credential types and templates, then issue tamper-evident, user-held credentials backed by the 1Kosmos distributed ledger.

25 endpoints

across 9 resource groups.

ECDSA-signed

every request is signed with your key pair.

JSON over HTTPS

predictable REST, conventional status codes.

OpenAPI 3.0

Download the spec →

Reference

Base URL

All Verifiable Credentials endpoints are relative to your environment host. Examples on this page use the 1Kosmos pilot environment — swap in your production root when you go live.

Pilot https://pilot-root.1kosmos.net/vcs

Content type

Requests and responses use application/json.

GEThttps://pilot-root.1kosmos.net/vcs/healthz

curl -X GET 'https://pilot-root.1kosmos.net/vcs/healthz' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

Security

Authentication

Verifiable Credentials uses ECDSA key-pair authentication. Each request carries your credentials as HTTP headers; verification-grade calls additionally sign the request body. Retrieve the system signing key from /publickeys.

Credentials

keyIdECDSA Public Keyheader

keySecretECDSA Private Keyheader

licenseLicense key from License Microserviceheader

GEThttps://pilot-root.1kosmos.net/vcs/healthz

cURL

Node.js

Python

curl -X GET 'https://pilot-root.1kosmos.net/vcs/healthz' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/healthz", {
  method: "GET",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/vcs/healthz",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

Reference

Errors

Verifiable Credentials uses conventional HTTP status codes: 2xx success, 4xx a problem with the request, 5xx a service-side error.

Status	Meaning	Description
200 / 204	OK	The request succeeded.
400	Bad Request	Validation failed.
401	Unauthorized	Missing or invalid credentials.
403	Forbidden	Authenticated, but not permitted.
404	Not Found	The resource does not exist.
500	Server Error	Something went wrong on our side.

4XXerror response

{
  "statusCode": 400,
  "error": "Bad Request",
  "message": "Validation error"
}

Verifiable Credentials

Credentials

Issue, fetch and revoke verifiable credentials.

GET/tenant/{tenantId}/community/{communityId}/vc/{vcId}/status

Get VC Status

Get a specific VC record by its ID

Auth: a valid community license key (any auth level)
key must be authorized for community.
returns VC Record object and its status

Parameters

tenantId (required)

Id of tenant

communityId (required)

Id of community

vcId (required)

Id of VC

Returns

returns VC Record object and its status

Path parameters

Name	Type	Description
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community
vcIdrequired	string	ID of VC

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

GEThttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/vc/{vcId}/status

cURL

Node.js

Python

curl -X GET 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc/xxxxxxxxxxxxxxxxxxxxxxxx/status' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc/xxxxxxxxxxxxxxxxxxxxxxxx/status", {
  method: "GET",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc/xxxxxxxxxxxxxxxxxxxxxxxx/status",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

RESPONSE

200

400

401

417

{
  "vcID": "xxxxxxxx",
  "tenantId": "xxxxxxxx",
  "communityId": "xxxxxxxx",
  "proof": {},
  "type": [
    "xxxxxxxx",
    "xxxxxxxx"
  ],
  "issueTS": 123456,
  "expiryTS": 123456,
  "status": "xxxxxxxx",
  "subject": {
    "did": "string",
    "publicKey": "string"
  },
  "issuer": "xxxxxxxx",
  "userURN": "string"
}

// no response body

// no response body

// no response body

GET/vc/{vcId}/download

Download VC using the id

Downloads a verifiable credential from the vc Id

Auth: a valid license key (any auth level)
returns encrypted vc with server's public key

Parameters

vcID (required)

Id of vc

Returns

Downloads a verifiable credential.

Path parameters

Name	Type	Description
vcIdrequired	string	ID of vc

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

GEThttps://pilot-root.1kosmos.net/vcs/vc/{vcId}/download

cURL

Node.js

Python

curl -X GET 'https://pilot-root.1kosmos.net/vcs/vc/xxxxxxxxxx/download' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/vc/xxxxxxxxxx/download", {
  method: "GET",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/vcs/vc/xxxxxxxxxx/download",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

RESPONSE

200

400

401

{
  "data": "xxxxxxxxxxxxxxxxxxxxx",
  "publicKey": "xxxxxxxxxxxxxxxxxxx"
}

// no response body

// no response body

GET/vp/{vpId}

Download VP using the uuid

Downloads a verifiable presentation with given uuid

Auth: a valid license key (any auth level)
returns encrypted vp with server's public key

Parameters

vpID (required)

uuid of vp

Returns

Downloads a verifiable presentation.

Path parameters

Name	Type	Description
vpIdrequired	string	UUID of vp

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

GEThttps://pilot-root.1kosmos.net/vcs/vp/{vpId}

cURL

Node.js

Python

curl -X GET 'https://pilot-root.1kosmos.net/vcs/vp/xxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/vp/xxxxxxxxxx", {
  method: "GET",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/vcs/vp/xxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

RESPONSE

200

400

401

{
  "data": "xxxxxxxxxxxxxxxxxxxxx",
  "publicKey": "xxxxxxxxxxxxxxxxxxx"
}

// no response body

// no response body

POST/tenant/{tenantId}/community/{communityId}/pass/create

create a pkpass

Issues a pkpass

Auth: a valid community license key (any auth level)
key must be authorized for community.

Parameters

tenantId (required)

Id of tenant

communityId (required)

Id of community

Request Body

vcs (required)

The verifiable credentials is type of array.

Returns

Issues a pkpass

Path parameters

Name	Type	Description
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

Request body

Request body contains below fields to issue vp.

{
    "vc": {
      "context": [
        "xxx",
        "xxxxxxx"
      ],
      "id": "xxxxxxx",
      "issuanceDate": "xxxxxxx",
      "issuer": "xxxxxxx",
      "expirationDate": "xxxxxxx",
        "type": [
        "xxxxxxx",
        "xxxxxxx"
      ],
      "credentialSubject": "xxxxxxx",
      "proof": {},
      "statusUrl": "xxxxxxxxxxxxxxxx"
    },
    "issueVP": boolean,
    "vpRequest": {
      "attributes": ["optional string array"],
      "ageToProve": number optional,
      "createShareUrl": boolean
     }
}

Field	Type	Description
vc	object	—

POSThttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/pass/create

cURL

Node.js

Python

curl -X POST 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/pass/create' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"vc": {}}'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/pass/create", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "vc": {}
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/pass/create",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "vc": {}
    },
)
print(res.json())

RESPONSE

400

401

417

Invalid request

// no response body

// no response body

// no response body

POST/tenant/{tenantId}/community/{communityId}/vc/from/document/{type}

Creates VC from verifiable document

Creates a verifiable credential from verified document

Auth: a valid community license key (any auth level)
key must be authorized for community.
sign a new vc from verified document
returns issued vc

Parameters

tenantId (required)

Id of tenant

communityId (required)

Id of community

type (required)

Supported types: dl

Request Body

document (required)

The document is of type object

did (required)

The did is of type string

publicKey (required)

The public key of user, which is of type string

userURN (optional)

The urn of user, which is of type string

Returns

Signs a verifiable credential from document.

Path parameters

Name	Type	Description
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community
typerequired	string	Type of credential;

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

Request body

Request body contains below fields to issue vc for dl.

{
    "document": {},
    "publicKey": "xxxxxxxxxx",
    "did": "xxxxxxxxxx",
    "userURN": "xxxxxxxxxx"
    "issueVP": boolean,
    "vpRequest": {
       "attributes": ["optional string array"],
       "ageToProve": number optional,
    }
}

Field	Type	Description
document	object	—
publicKey	string	—
did	string	—
userURN	string	—

POSThttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/vc/from/document/{type}

cURL

Node.js

Python

curl -X POST 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc/from/document/xxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"document": {}, "publicKey": "xxxxxxxxxx", "did": "xxxxxxxxxx", "userURN": "xxxxxxxxxx", "issueVP": "boolean,", "vpRequest": {"attributes": ["string"], "ageToProve": "number"}}'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc/from/document/xxxxxx", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "document": {},
    "publicKey": "xxxxxxxxxx",
    "did": "xxxxxxxxxx",
    "userURN": "xxxxxxxxxx",
    "issueVP": "boolean,",
    "vpRequest": {
      "attributes": [
        "string"
      ],
      "ageToProve": "number"
    }
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc/from/document/xxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "document": {},
      "publicKey": "xxxxxxxxxx",
      "did": "xxxxxxxxxx",
      "userURN": "xxxxxxxxxx",
      "issueVP": "boolean,",
      "vpRequest": {
        "attributes": [
          "string"
        ],
        "ageToProve": "number"
      }
    },
)
print(res.json())

RESPONSE

200

400

401

{
  "vc": {
    "context": [
      "xxx",
      "xxxxxxx"
    ],
    "issuanceDate": "xxxxxxx",
    "issuer": "xxxxxxx",
    "expirationDate": "xxxxxxx",
    "type": [
      "xxxxxxx",
      "xxxxxxx"
    ],
    "credentialSubject": "xxxxxxx",
    "proof": {},
    "statusUrl": "xxxxxxxxxxxxxxxxxxxxxx"
  }
}

// no response body

// no response body

POST/tenant/{tenantId}/community/{communityId}/vc/from/payload/{type}

Creates a VC from payload

Issues a verifiable credential from payload

Auth: a valid community license key (auth level system, service or service_ext)
key must be authorized for community.
signs a new vc from payload
returns issued vc with download url

Parameters

tenantId (required)

Id of tenant

communityId (required)

Id of community

type (required)

Supported types: employment_card

Request Body

info (required)

The info is of type object

did (optional)

The did is of type string

issuer (required)

The is of type object

publicKey (optional)

The public key of user, which is of type string

userURN (optional)

The urn of user, which is of type string

Returns

Signs a verifiable credential from payload.

Path parameters

Name	Type	Description
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community
typerequired	string	Type of credential;

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

Request body

Request body contains below fields to issue vc.

{
  "info": {
     "id": "string required",
     "firstName": "string required",
     "lastName": "string required",
     "companyName": "string required",
     "companyAddress": "string required",
     "department": "string optional",
     "title": "string optional",
     "doe": "string required (format yyyymmdd)"
     "xx": "string, number or boolean optional"
 },
 "did": "string required",
 "publicKey": "string required",
 "issuer": {
     "id": "string required"
     "xx": "string optional"
  }
 "userURN": "string optional",
 "issueVP": boolean,
 "vpRequest": {
    "attributes": ["optional string array"],
    "ageToProve": number optional,
    "createShareUrl": boolean
 }

}

Field	Type	Description
vc	object	—

POSThttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/vc/from/payload/{type}

cURL

Node.js

Python

curl -X POST 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc/from/payload/xxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"info": {"id": "xxxxxxxxxx", "firstName": "xxxxxxxxxxxx", "lastName": "xxxxxxxxxxxxxx", "companyName": "xxxxxxxxxxxxx", "companyAddress": "xxxxxxxxxxxxx", "department": "xxxxxxxxxxxxxx", "title": "xxxxxxxxxxxxxxxx", "doe": "xxxxxxxxxxxxx (format yyyymmdd)", "xxxx": "xxxxxxxxxxxx (string number or boolean)"}, "did": "xxxxxxxxxxxxxxxxx,", "publicKey": "XXXXXXXXX", "issuer": {"id": "xxxxxxxxxxxxxxxxxxx", "xxxx": "xxxxxxxxxxxx (any key and value)"}, "userURN": "xxxxxxxxxxxxxxxxx,", "issueVP": "boolean,", "vpRequest": {"attributes": ["string"], "ageToProve": "number", "createShareUrl": "boolean"}}'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc/from/payload/xxxxxx", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "info": {
      "id": "xxxxxxxxxx",
      "firstName": "xxxxxxxxxxxx",
      "lastName": "xxxxxxxxxxxxxx",
      "companyName": "xxxxxxxxxxxxx",
      "companyAddress": "xxxxxxxxxxxxx",
      "department": "xxxxxxxxxxxxxx",
      "title": "xxxxxxxxxxxxxxxx",
      "doe": "xxxxxxxxxxxxx (format yyyymmdd)",
      "xxxx": "xxxxxxxxxxxx (string number or boolean)"
    },
    "did": "xxxxxxxxxxxxxxxxx,",
    "publicKey": "XXXXXXXXX",
    "issuer": {
      "id": "xxxxxxxxxxxxxxxxxxx",
      "xxxx": "xxxxxxxxxxxx (any key and value)"
    },
    "userURN": "xxxxxxxxxxxxxxxxx,",
    "issueVP": "boolean,",
    "vpRequest": {
      "attributes": [
        "string"
      ],
      "ageToProve": "number",
      "createShareUrl": "boolean"
    }
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc/from/payload/xxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "info": {
        "id": "xxxxxxxxxx",
        "firstName": "xxxxxxxxxxxx",
        "lastName": "xxxxxxxxxxxxxx",
        "companyName": "xxxxxxxxxxxxx",
        "companyAddress": "xxxxxxxxxxxxx",
        "department": "xxxxxxxxxxxxxx",
        "title": "xxxxxxxxxxxxxxxx",
        "doe": "xxxxxxxxxxxxx (format yyyymmdd)",
        "xxxx": "xxxxxxxxxxxx (string number or boolean)"
      },
      "did": "xxxxxxxxxxxxxxxxx,",
      "publicKey": "XXXXXXXXX",
      "issuer": {
        "id": "xxxxxxxxxxxxxxxxxxx",
        "xxxx": "xxxxxxxxxxxx (any key and value)"
      },
      "userURN": "xxxxxxxxxxxxxxxxx,",
      "issueVP": "boolean,",
      "vpRequest": {
        "attributes": [
          "string"
        ],
        "ageToProve": "number",
        "createShareUrl": "boolean"
      }
    },
)
print(res.json())

RESPONSE

200

400

401

{
  "vc": {
    "context": [
      "xxx",
      "xxxxxxx"
    ],
    "issuanceDate": "xxxxxxx",
    "issuer": "xxxxxxx",
    "expirationDate": "xxxxxxx",
    "type": [
      "xxxxxxx",
      "xxxxxxx"
    ],
    "credentialSubject": "xxxxxxx",
    "proof": {},
    "statusUrl": "xxxxxxxxxxxxxxxx"
  },
  "vcId": "xxxxxxxxxxxxxxxx",
  "download_url": "xxxxxxxxxxxxxxx"
}

// no response body

// no response body

POST/tenant/{tenantId}/community/{communityId}/vc/verify

Verifies a VC

Verifies a signed verifiable credential

Auth: a valid community license key (any auth level)
key must be authorized for community.
verifies a signed vc
returns status of verification and VC data.

Parameters

tenantId (required)

Id of tenant

communityId (required)

Id of community

Request Body

vc (required)

The vc is type of object.

Returns

Verifies a verifiable credential.

Path parameters

Name	Type	Description
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

Request body

Request body contains below fields to verify vc.

{
   "vc": {
    "context": [
     "xxx",
     "xxxxxxx"
    ],
    "issuanceDate": "xxxxxxx",
    "issuer": "xxxxxxx",
    "expirationDate": "xxxxxxx",
    "type": [
      "xxxxxxx",
      "xxxxxxx"
    ],
    "credentialSubject": "xxxxxxx",
    "proof": {},
    "statusUrl": "xxxxxxxxxxxxxxxx"
  } 
}

Field	Type	Description
vc	object	—

POSThttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/vc/verify

cURL

Node.js

Python

curl -X POST 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc/verify' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"vc": {}}'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc/verify", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "vc": {}
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc/verify",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "vc": {}
    },
)
print(res.json())

RESPONSE

200

400

401

417

{
  "verified": true,
  "status": {
    "vcID": "xxxxxxxx",
    "tenantId": "xxxxxxxx",
    "communityId": "xxxxxxxx",
    "proof": {},
    "type": [
      "xxxxxxxx",
      "xxxxxxxx"
    ],
    "issueTS": 123456,
    "expiryTS": 123456,
    "status": "xxxxxxxx",
    "subject": {
      "did": "string",
      "publicKey": "string"
    },
    "issuer": "xxxxxxxx",
    "userURN": "string"
  }
}

// no response body

// no response body

// no response body

POST/tenant/{tenantId}/community/{communityId}/vp/create

Issues a VP

Issues a verifiable presentation

Auth: a valid community license key (any auth level)
key must be authorized for community.
issues a presenrtation for a collection of VCs
returns a signed verifiable presentation

Parameters

tenantId (required)

Id of tenant

communityId (required)

Id of community

Request Body

vcs (required)

The verifiable credentials is type of array.

Returns

Issues a verifiable presentation for credentials.

Path parameters

Name	Type	Description
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

POSThttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/vp/create

cURL

Node.js

Python

curl -X POST 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vp/create' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"vcs": [{"vc": {}, "attributes": ["string"], "ageToProve": "number"}]}'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vp/create", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "vcs": [
      {
        "vc": {},
        "attributes": [
          "string"
        ],
        "ageToProve": "number"
      }
    ]
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vp/create",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "vcs": [
        {
          "vc": {},
          "attributes": [
            "string"
          ],
          "ageToProve": "number"
        }
      ]
    },
)
print(res.json())

RESPONSE

200

400

401

417

{
  "vp": {
    "context": [
      "xxxxx"
    ],
    "type": [
      "xxxxxxxxx"
    ],
    "verifiableCredential": [
      {
        "context": [
          "xxx",
          "xxxxxxx"
        ],
        "issuanceDate": "xxxxxxx",
        "issuer": "xxxxxxx",
        "expirationDate": "xxxxxxx",
        "type": [
          "xxxxxxx",
          "xxxxxxx"
        ],
        "credentialSubject": "xxxxxxx",
        "proof": {}
      }
    ],
    "proof": {}
  }
}

// no response body

// no response body

// no response body

POST/tenant/{tenantId}/community/{communityId}/vp/verify

Verifies a VP

Verifyes a verifiable presentation

Auth: a valid community license key (any auth level)
key must be authorized for community.
verifies a presentation
returns a verified status of VP, VC data and age verification result

Parameters

tenantId (required)

Id of tenant

communityId (required)

Id of community

Request Body

vp (required)

The vp is type of object.

Returns

Verifies a verifiable credential.

Path parameters

Name	Type	Description
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

Request body

Request body contains below fields to verify a vp

{
  "vp": {
    "context": [
      "xxxxx"
    ],
   "type": [
      "xxxxxxxxx"
   ],
   "verifiableCredential": [
     {
       "context": [
         "xxx",
         "xxxxxxx"
       ],
       "issuanceDate": "xxxxxxx",
       "issuer": "xxxxxxx",
       "expirationDate": "xxxxxxx",
       "type": [
         "xxxxxxx",
         "xxxxxxx"
       ],
      "credentialSubject": "xxxxxxx",
     "proof": {}
    }
  ],
  "proof": {}
}

Field	Type	Description
vp	object	—

POSThttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/vp/verify

cURL

Node.js

Python

curl -X POST 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vp/verify' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"vp": {}}'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vp/verify", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "vp": {}
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vp/verify",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "vp": {}
    },
)
print(res.json())

RESPONSE

200

400

401

417

{
  "verified": true,
  "vc_status": [
    {
      "vcID": "xxxxxxxx",
      "tenantId": "xxxxxxxx",
      "communityId": "xxxxxxxx",
      "proof": {},
      "type": [
        "xxxxxxxx",
        "xxxxxxxx"
      ],
      "issueTS": 123456,
      "expiryTS": 123456,
      "status": "xxxxxxxx",
      "subject": {
        "did": "string",
        "publicKey": "string"
      },
      "issuer": "xxxxxxxx",
      "userURN": "string"
    }
  ],
  "ageVerified": true
}

// no response body

// no response body

// no response body

Verifiable Credentials

VC Types

Define credential types.

GET/tenant/{tenantId}/community/{communityId}/vc_type/{type}/templates

Fetches all available UI templates associated with vc_type

Fetches all available UI templates (info, card, detail, pass) for tenant and community and vc type combination

Auth: a valid license key (system, service, service_ext)
returns json containing UI templates (info, card, detail, pass)

Returns

List of Vc Types, please see 200 response.

Path parameters

Name	Type	Description
typerequired	string	vc_type (e.g. VerifiedEmployee \| VerifiedConsultant)
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

GEThttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/vc_type/{type}/templates

cURL

Node.js

Python

curl -X GET 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_type/VerifiedEmployee/templates' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_type/VerifiedEmployee/templates", {
  method: "GET",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_type/VerifiedEmployee/templates",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

RESPONSE

200

401

404

{
  "info": "string",
  "card": "string",
  "detail": "string",
  "pass": "string"
}

// no response body

// no response body

POST/tenant/{tenantId}/community/{communityId}/vc_types/fetch

Fetches all available VC Types

Fetches all available Vc Types for tenant and community combination

Auth: a valid license key (system, service, service_ext)
returns json array containing record of Vc Types saved

Returns

List of Vc Types, please see 200 response.

Path parameters

Name	Type	Description
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

POSThttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/vc_types/fetch

cURL

Node.js

Python

curl -X POST 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_types/fetch' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_types/fetch", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_types/fetch",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

RESPONSE

200

401

[
  {
    "name": "string",
    "type": "VerifiedEmployee | VerifiedConsultant",
    "template": {
      "info": "string",
      "card": "string",
      "detail": "string",
      "pass": "string"
    }
  }
]

// no response body

PUT/tenant/{tenantId}/community/{communityId}/vc_type

Add VC Type

Adds VC type credential for specific community and tenant

Auth: a valid license key (system, service, service_ext)
returns json containing object id of record saved (unencrypted)

Returns

json payload including id of saved template (mongo object id).

Path parameters

Name	Type	Description
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

Request body

Request body contains below fields to issue vc for dl.

{
    "name": "xxxxxxxxxx",
    "type": "VerifiedEmployee | VerifiedConsultant",
    "template": {
       "info": "xxxxxxxxxx",
       "card": "xxxxxxxxxx",
       "detail": "xxxxxxxxxx",
       "pass": "xxxxxxxxxx"
     }
}

Field	Type	Description
name	string	—
type	string	—
template	object	—

PUThttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/vc_type

cURL

Node.js

Python

curl -X PUT 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_type' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"name": "string", "type": "VerifiedEmployee | VerifiedConsultant", "template": {"info": "string", "card": "string", "detail": "string", "pass": "string"}}'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_type", {
  method: "PUT",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "name": "string",
    "type": "VerifiedEmployee | VerifiedConsultant",
    "template": {
      "info": "string",
      "card": "string",
      "detail": "string",
      "pass": "string"
    }
  })
});
const data = await res.json();

import requests

res = requests.put(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_type",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "name": "string",
      "type": "VerifiedEmployee | VerifiedConsultant",
      "template": {
        "info": "string",
        "card": "string",
        "detail": "string",
        "pass": "string"
      }
    },
)
print(res.json())

RESPONSE

200

401

{
  "id": "string"
}

// no response body

PATCH/tenant/{tenantId}/community/{communityId}/vc_type/{id}

Updates VC Type

Updates VC Type for VC for specific community and tenant

Auth: a valid license key (system, service, service_ext)
returns json containing object id of record saved (unencrypted)

Returns

json payload including id of updated vc type (mongo object id).

Path parameters

Name	Type	Description
idrequired	string	ID of Template
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

Request body

Request body contains below fields to issue vc for dl.

{
    "name": "xxxxxxxxxx", //optional
    "template": {
       "info": "xxxxxxxxxx", //optional
       "card": "xxxxxxxxxx", //optional
       "detail": "xxxxxxxxxx" //optional,
       "pass": "xxxxxxxxxx" //optional
     }
}

Field	Type	Description
name	string	—
template	object	—

PATCHhttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/vc_type/{id}

cURL

Node.js

Python

curl -X PATCH 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_type/xxxxxxxxxxxxxxxxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"name": "string", "template": {"info": "string", "card": "string", "detail": "string", "pass": "string"}}'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_type/xxxxxxxxxxxxxxxxxxxxxxxx", {
  method: "PATCH",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "name": "string",
    "template": {
      "info": "string",
      "card": "string",
      "detail": "string",
      "pass": "string"
    }
  })
});
const data = await res.json();

import requests

res = requests.patch(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_type/xxxxxxxxxxxxxxxxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "name": "string",
      "template": {
        "info": "string",
        "card": "string",
        "detail": "string",
        "pass": "string"
      }
    },
)
print(res.json())

RESPONSE

200

401

404

{
  "id": "string"
}

// no response body

// no response body

DELETE/tenant/{tenantId}/community/{communityId}/vc_type/{id}

Delete VC Type template

Deletes Vc Type for VC for specific community and tenant by id

Auth: a valid license key (system, service, service_ext)

Returns

200 status if operation is successful.

Path parameters

Name	Type	Description
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community
idrequired	string	ID of Vc Type

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

DELETEhttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/vc_type/{id}

cURL

Node.js

Python

curl -X DELETE 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_type/xxxxxxxxxxxxxxxxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_type/xxxxxxxxxxxxxxxxxxxxxxxx", {
  method: "DELETE",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.delete(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/vc_type/xxxxxxxxxxxxxxxxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

RESPONSE

200

401

404

Deleted successfully

// no response body

// no response body

// no response body

Verifiable Credentials

Templates

Credential templates.

POST/tenant/{tenantId}/community/{communityId}/templates/fetch

Fetches all available templates

Fetches all available UI Templates for tenant and community combination

Auth: a valid license key (system, service, service_ext)
returns json array containing record or UI templates saved

Returns

List of UI templates, please see 200 response.

Path parameters

Name	Type	Description
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

POSThttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/templates/fetch

cURL

Node.js

Python

curl -X POST 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/templates/fetch' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/templates/fetch", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/templates/fetch",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

RESPONSE

200

401

[
  {
    "id": "string",
    "uid": "string",
    "name": "string",
    "b64": "string",
    "view": "string",
    "communityId": "string",
    "tenantId": "string"
  }
]

// no response body

PUT/tenant/{tenantId}/community/{communityId}/template

Add UI VC template

Adds UI template for VC for specific community and tenant

Auth: a valid license key (system, service, service_ext)
returns json containing object id of record saved (unencrypted)

Returns

json payload including id of saved template (mongo object id).

Path parameters

Name	Type	Description
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

Request body

Request body contains below fields to issue vc for dl.

{
    "uid": "xxxxxxxxxx", //must be UUID4 e.g. 7e5c9c44-0981-44c6-9c8f-0ba6785a1598
    "name": "xxxxxxxxxx",
    "b64": "xxxxxxxxxx", //base 64 of html template
    "view": "xxxxxxxxxx" //[info, card, detail, pass]
}

Field	Type	Description
uid	string	—
name	string	—
b64	string	—
view	string	—

PUThttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/template

cURL

Node.js

Python

curl -X PUT 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/template' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"uid": "7e5c9c44-0981-44c6-9c8f-0ba6785a1598", "name": "string", "b64": "string", "view": "info"}'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/template", {
  method: "PUT",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "uid": "7e5c9c44-0981-44c6-9c8f-0ba6785a1598",
    "name": "string",
    "b64": "string",
    "view": "info"
  })
});
const data = await res.json();

import requests

res = requests.put(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/template",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "uid": "7e5c9c44-0981-44c6-9c8f-0ba6785a1598",
      "name": "string",
      "b64": "string",
      "view": "info"
    },
)
print(res.json())

RESPONSE

200

401

{
  "id": "string"
}

// no response body

PATCH/tenant/{tenantId}/community/{communityId}/template/{id}

Updates UI VC template

Updates UI template for VC for specific community and tenant

Auth: a valid license key (system, service, service_ext)
returns json containing object id of record saved (unencrypted)

Returns

json payload including id of updated template (mongo object id).

Path parameters

Name	Type	Description
idrequired	string	ID of Template
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

Request body

Request body contains below fields to issue vc for dl.

{
    "name": "xxxxxxxxxx",
    "b64": "xxxxxxxxxx" //base 64 of html template
}

Field	Type	Description
name	string	—
b64	string	—

PATCHhttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/template/{id}

cURL

Node.js

Python

curl -X PATCH 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/template/xxxxxxxxxxxxxxxxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"name": "string", "b64": "string"}'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/template/xxxxxxxxxxxxxxxxxxxxxxxx", {
  method: "PATCH",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "name": "string",
    "b64": "string"
  })
});
const data = await res.json();

import requests

res = requests.patch(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/template/xxxxxxxxxxxxxxxxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "name": "string",
      "b64": "string"
    },
)
print(res.json())

RESPONSE

200

401

404

{
  "id": "string"
}

// no response body

// no response body

DELETE/tenant/{tenantId}/community/{communityId}/template/{id}

Delete UI VC template, If UI template is being actively used in VC type then this api will not be allowed

Deletes UI template for VC for specific community and tenant by id

Auth: a valid license key (system, service, service_ext)
returns json containing object id of record saved (unencrypted)

Returns

200 status if operation is successful.

Path parameters

Name	Type	Description
idrequired	string	ID of template
tenantIdrequired	string	ID of tenant
communityIdrequired	string	ID of community

Headers

Name	Type	Description
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒

DELETEhttps://pilot-root.1kosmos.net/vcs/tenant/{tenantId}/community/{communityId}/template/{id}

cURL

Node.js

Python

curl -X DELETE 'https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/template/xxxxxxxxxxxxxxxxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/template/xxxxxxxxxxxxxxxxxxxxxxxx", {
  method: "DELETE",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.delete(
    "https://pilot-root.1kosmos.net/vcs/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/template/xxxxxxxxxxxxxxxxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

RESPONSE

200

401

404

405

Deleted successfully

// no response body

// no response body

// no response body

// no response body

Verifiable Credentials

Service Key

Service Key endpoints.

GET/servicekeys

Get service keys

This endpoint returns available service keys. The license you are using must be of authLevel 'system'

Headers

licensekey (required)

License key

Returns

Returns array with service keys

Headers

Name	Type	Description
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒

GEThttps://pilot-root.1kosmos.net/vcs/servicekeys

cURL

Node.js

Python

curl -X GET 'https://pilot-root.1kosmos.net/vcs/servicekeys' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/servicekeys", {
  method: "GET",
  headers: {
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "licensekey": "YOUR_LICENSE_KEY",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/vcs/servicekeys",
    headers={
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "licensekey": "YOUR_LICENSE_KEY",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

RESPONSE

200

400

401

500

501

Success

[
  {
    "tag": "xxxxx",
    "keyId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxx",
    "keySecret": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxx",
    "type": "xxxxx"
  }
]

// no response body

// no response body

// no response body

// no response body

DELETE/servicekey/{keyId}

Reset Service Key

This endpoint resets service key for given keyId. Deletes current one and recreates a new one. The license you are using must be of authLevel 'system'

Parameters

keyId (required)

The keyId of service key to reset

Headers

licensekey (required)

License key encrypted with ECDSA

requestid (required)

JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now

publickey (required)

Public key

Returns

Returns re-created service key

Path parameters

Name	Type	Description
keyIdrequired	string	keyId of service key to reset

Headers

Name	Type	Description
requestidrequired	string	JSON string encrypted with ECDSA which should contain "appid" (string), "uuid" (string) and "ts" (number) representing epoch timestamp in seconds - it shouldn't be more or less than 'environment.allowed_time_span' seconds from now / Try Authorize 🔒
publickeyrequired	string	Public Key / Try Authorize 🔒
licensekeyrequired	string	License key encrypted with ECDSA / Try Authorize 🔒

DELETEhttps://pilot-root.1kosmos.net/vcs/servicekey/{keyId}

cURL

Node.js

Python

curl -X DELETE 'https://pilot-root.1kosmos.net/vcs/servicekey/<keyId>' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/servicekey/<keyId>", {
  method: "DELETE",
  headers: {
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "licensekey": "YOUR_LICENSE_KEY",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.delete(
    "https://pilot-root.1kosmos.net/vcs/servicekey/<keyId>",
    headers={
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "licensekey": "YOUR_LICENSE_KEY",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

RESPONSE

200

400

401

500

501

Success

[
  {
    "tag": "xxxxx",
    "keyId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxx",
    "keySecret": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxx",
    "type": "xxxxx"
  }
]

// no response body

// no response body

// no response body

// no response body

Verifiable Credentials

ECDSA Helper

ECDSA Helper endpoints.

POST/ecdsa_helper/{method}

Encrypt and decrypt the data string by public key and private key.

Parameters

method (optional)

The method parameter is type of enum. Default value is encrypt.

This parameter only accepts following values

encrypt, decrypt

Request Body

dataStr (required)

The dataStr key is type of string.

publicKey (required)

The publicKey is type of string.

privateKey (required)

The privateKey is type of string.

Returns

Returns the encrypted/decrypted string.

This API throw an error if something goes wrong. A common source of error is public or private key is not valid.

Path parameters

Name	Type	Description
method	string	—

Request body

Field	Type	Description
dataStr	string	—
publicKey	string	—
privateKey	string	—

POSThttps://pilot-root.1kosmos.net/vcs/ecdsa_helper/{method}

cURL

Node.js

Python

curl -X POST 'https://pilot-root.1kosmos.net/vcs/ecdsa_helper/<method>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"dataStr": "Hey, This is example data string.", "publicKey": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx=", "privateKey": "xxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="}'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/ecdsa_helper/<method>", {
  method: "POST",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "dataStr": "Hey, This is example data string.",
    "publicKey": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx=",
    "privateKey": "xxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/vcs/ecdsa_helper/<method>",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "dataStr": "Hey, This is example data string.",
      "publicKey": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx=",
      "privateKey": "xxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
    },
)
print(res.json())

RESPONSE

200

successful operation

{
  "data": "xxxxxxxxxxxxxxxxxxxx"
}

Verifiable Credentials

Environment

Environment endpoints.

GET/environment

/environment

Provide details regarding the environments.

Returns

Returns an environment object

GEThttps://pilot-root.1kosmos.net/vcs/environment

cURL

Node.js

Python

curl -X GET 'https://pilot-root.1kosmos.net/vcs/environment' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/environment", {
  method: "GET",
  headers: {
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/vcs/environment",
    headers={
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

RESPONSE

200

Success

// no response body

Verifiable Credentials

Healthz

Healthz endpoints.

GET/healthz

Get healthz.

Get healthz

Returns

Returns a healthz object

``version = <git-tag>.<commit-id>.<dob>``

``git-tag``: When code is compiled from a git-tag, this must carry the tag name. This should match one of the git tags.

``commit-id``: This is the git-commit-id. eg: When code is built from this, the hex code, in the end, is the commit it.

``dob``: Date Of Build. This is epoc-time-in-seconds that tell the time when the build was created.

if the code is not built from a git-tag, then the ``version =<commit-id>.<dob>``

GEThttps://pilot-root.1kosmos.net/vcs/healthz

cURL

Node.js

Python

curl -X GET 'https://pilot-root.1kosmos.net/vcs/healthz' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/healthz", {
  method: "GET",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/vcs/healthz",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

RESPONSE

200

Success ``` { "status": "all services operational", "publicKey": "string" //same as <service>/publickeys endpoint, "code": "200", "version": "<version>" //as defined above } ```

{
  "status": "all services operational",
  "publicKey": "//same as <service>/publickeys endpoint",
  "code": "200",
  "version": "xxxx.xxxx.xxxx"
}

Verifiable Credentials

Public Key

Public Key endpoints.

GET/publickeys

Get system's public key

Get system's public key. No authorization

Returns

Returns a public key object

GEThttps://pilot-root.1kosmos.net/vcs/publickeys

cURL

Node.js

Python

curl -X GET 'https://pilot-root.1kosmos.net/vcs/publickeys' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/publickeys", {
  method: "GET",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/vcs/publickeys",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

RESPONSE

200

404

{
  "publicKey": "",
  "vc": [
    {
      "type": "",
      "publicKey": ""
    }
  ]
}

// no response body

Verifiable Credentials

Service Directory

Service Directory endpoints.

GET/sd

Get all service directories.

If the API is call on external_sd=true then it will return external URLs

Returns

Returns all service directories.

Query parameters

Name	Type	Description
external_sd	boolean	external_sd is used to generate external URLs.

GEThttps://pilot-root.1kosmos.net/vcs/sd

cURL

Node.js

Python

curl -X GET 'https://pilot-root.1kosmos.net/vcs/sd?external_sd=True' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/vcs/sd?external_sd=True", {
  method: "GET",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/vcs/sd?external_sd=True",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

RESPONSE

200

404

{
  "name1": "https://xxx.xxxxxx.xxx/xxxxx",
  "name2": "https://xxx.xxxxxx.xxx/xxxxx",
  "name3": "https://xxx.xxxxxx.xxx/xxxxx"
}

// no response body