REST API

The SignPlus REST API does what the panel on the page does, from another system: start a signing, follow it, list who has not signed, export a PDF and fetch the signed document. It authenticates with an Atlassian service account, and it covers signing only, not Confluence in general.

Every example comes three ways: an Oktul Code Studio script, a Forge app and curl.

Before you start

The client_id and client_secret are shown once, when the credential is created.

Full size

What the service account may do

SignPlus checks the service account’s own Confluence permissions on every request and reads the page as that account. More scopes on the credential grant nothing extra.

Because the page is read as the service account, the signed document holds what that account sees: a Jira work items table lists the work items it may see, and an excerpt from a page it cannot open is left out.

Connect a client

Code Studio

Code Studio holds the credential in a connection and adds a fresh token to every request, so a script never sees the secret.

Forge

A Forge app declares the two hosts, keeps the credential in encrypted variables and fetches the token itself.

permissions:
  external:
    fetch:
      backend:
        - address: auth.atlassian.com
        - address: your-installation.hello.atlassian.net

forge variables set SIGNPLUS_URL https://your-installation.hello.atlassian.net/x1/...
forge variables set --encrypt SIGNPLUS_CLIENT_ID <client id>
forge variables set --encrypt SIGNPLUS_CLIENT_SECRET <client secret>

import { fetch } from '@forge/api';

let cached;

export async function signplusToken() {
  if (cached && cached.expires > Date.now() + 60_000) {
    return cached.token;
  }

  const response = await fetch('https://auth.atlassian.com/oauth/token', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      grant_type: 'client_credentials',
      client_id: process.env.SIGNPLUS_CLIENT_ID,
      client_secret: process.env.SIGNPLUS_CLIENT_SECRET
    })
  });

  if (!response.ok) {
    throw new Error(`The token request failed: ${response.status}`);
  }

  const { access_token: token, expires_in: seconds } = await response.json();
  cached = { token, expires: Date.now() + seconds * 1000 };

  return token;
}

curl

Fetch a token with the client id and secret in the body of a POST. They are read from the environment, so the secret never appears on a command line.

export SIGNPLUS_URL="https://513c7988-....hello.atlassian.net/x1/G7gth8r-Vw5-wMfGB7FGgW6AQ9A"
export CLIENT_ID=... CLIENT_SECRET=...

export SIGNPLUS_TOKEN=$(jq -n '{grant_type: "client_credentials", client_id: env.CLIENT_ID, client_secret: env.CLIENT_SECRET}' \
  | curl -s -X POST 'https://auth.atlassian.com/oauth/token' \
      -H 'Content-Type: application/json' --data @- \
  | jq -r .access_token)

The token lasts 60 minutes. Fetch a new one when a request answers 401.

Your first signing

Four requests: check the page, start the signing, follow the job, and see who has not signed. A page id is in the page’s address, or under Page information.

1. Check where the page stands

export default async function () {
    return http.get('signplus', '/v1/pages/123456/status');
}

import { fetch } from '@forge/api';
import { signplusToken } from './signplus';

const response = await fetch(`${process.env.SIGNPLUS_URL}/v1/pages/123456/status`, {
  headers: { Authorization: `Bearer ${await signplusToken()}` }
});
console.log(await response.json());

curl -s "$SIGNPLUS_URL/v1/pages/123456/status" -H "Authorization: Bearer $SIGNPLUS_TOKEN"

{
  "pageId": "123456",
  "spaceId": "98765",
  "pageVersion": 4,
  "state": "ready-to-sign",
  "signings": []
}

401 means the token is wrong or has expired. 403 means the service account cannot see the page.

2. Start a signing

export default async function () {
    return http.post('signplus', '/v1/signings', {
        pageId: '123456',
        signers: [
            { email: 'anna@example.com', name: 'Anna Tamm' },
            { group: 'finance-team' },
        ],
    });
}

import { fetch } from '@forge/api';
import { signplusToken } from './signplus';

const response = await fetch(`${process.env.SIGNPLUS_URL}/v1/signings`, {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${await signplusToken()}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    pageId: '123456',
    signers: [
      { email: 'anna@example.com', name: 'Anna Tamm' },
      { group: 'finance-team' }
    ]
  })
});
console.log(await response.json());

curl -s -X POST "$SIGNPLUS_URL/v1/signings" \
  -H "Authorization: Bearer $SIGNPLUS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "pageId": "123456",
    "signers": [
      { "email": "anna@example.com", "name": "Anna Tamm" },
      { "group": "finance-team" }
    ]
  }'

{
  "jobId": "7c1e9a0f3b2d4c5e6f7a8b9c",
  "status": "queued",
  "pageId": "123456",
  "statusUrl": "/v1/pages/123456/signing-jobs/7c1e9a0f3b2d4c5e6f7a8b9c"
}

The answer is 202 Accepted. The request has passed the space’s settings, and the signing is prepared in the background: the page is rendered, each group is expanded into its members, and everyone is sent to Dokobit. That takes seconds for a few people and minutes for thousands.

3. Follow the job

export default async function () {
    return http.get('signplus', '/v1/pages/123456/signing-jobs/7c1e9a0f3b2d4c5e6f7a8b9c');
}

import { fetch } from '@forge/api';
import { signplusToken } from './signplus';

const response = await fetch(`${process.env.SIGNPLUS_URL}/v1/pages/123456/signing-jobs/7c1e9a0f3b2d4c5e6f7a8b9c`, {
  headers: { Authorization: `Bearer ${await signplusToken()}` }
});
console.log(await response.json());

curl -s "$SIGNPLUS_URL/v1/pages/123456/signing-jobs/7c1e9a0f3b2d4c5e6f7a8b9c" \
  -H "Authorization: Bearer $SIGNPLUS_TOKEN"

{
  "id": "7c1e9a0f3b2d4c5e6f7a8b9c",
  "status": "started",
  "reference": "a3f9c2d1e4b5a6978877665544332211",
  "documentName": "Expense policy"
}

4. See who has not signed

export default async function () {
    const { signers } = await http.get('signplus', '/v1/signings/a3f9c2d1e4b5a6978877665544332211/signers', {
        query: { pageId: '123456', status: 'pending' },
    });
    return signers.map((signer) => `${signer.name} <${signer.email}>`);
}

import { fetch } from '@forge/api';
import { signplusToken } from './signplus';

const response = await fetch(`${process.env.SIGNPLUS_URL}/v1/signings/a3f9c2d1e4b5a6978877665544332211/signers?pageId=123456&status=pending`, {
  headers: { Authorization: `Bearer ${await signplusToken()}` }
});
const { signers } = await response.json();
console.log(signers.map((signer) => `${signer.name} <${signer.email}>`));

curl -s "$SIGNPLUS_URL/v1/signings/a3f9c2d1e4b5a6978877665544332211/signers?pageId=123456&status=pending" \
  -H "Authorization: Bearer $SIGNPLUS_TOKEN" | jq -r '.signers[] | [.name, .email] | @tsv'

Authentication and limits

Every request carries one header, Authorization: Bearer <access token>. Basic authentication is not supported.

• Every authentication failure answers the same 401, so the API cannot be used to find out which tokens are live.
• A revoked credential stops working within two minutes. SignPlus remembers a verified token for two minutes, then asks Atlassian again. Revoke the credential in Atlassian Administration to stop an integration.
• A token from another Atlassian organisation is refused by Atlassian itself.

Every request, a refused one included, is recorded under Logs in the global settings: what was called, the outcome and the account it acted as, never the token. Two kinds are not recorded: a body over 2MB or not valid JSON, and any request while the site has no active licence.

Operations

Every reply is JSON, errors included. Every operation that takes a reference also needs pageId, so a reference from one page cannot reach a signing on another. Identifiers are checked before anything reads them: a page id is a number, a reference 32 characters of 0-9 and a-f, a job id 24. Anything else answers 400.

Signing operations

export default async function () {
    return http.post('signplus', '/v1/signings', {
        pageId: '123456',
        signers: [
            {
                email: 'anna@example.com',
                name: 'Anna Tamm',
            },
            {
                group: 'finance-team',
            },
            {
                email: 'jaan@example.com',
                name: 'Jaan Kask',
                role: 'viewer',
            },
        ],
        name: 'Expense policy 2026',
        message: 'Please sign by Friday',
        deadline: '2026-12-31T17:00:00+02:00',
    });
}

import { fetch } from '@forge/api';
import { signplusToken } from './signplus';

var bodyData = `{
  "pageId": "123456",
  "signers": [
    {
      "email": "anna@example.com",
      "name": "Anna Tamm"
    },
    {
      "group": "finance-team"
    },
    {
      "email": "jaan@example.com",
      "name": "Jaan Kask",
      "role": "viewer"
    }
  ],
  "name": "Expense policy 2026",
  "message": "Please sign by Friday",
  "deadline": "2026-12-31T17:00:00+02:00"
}`;

const response = await fetch(`${process.env.SIGNPLUS_URL}/v1/signings`, {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${await signplusToken()}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: bodyData
});

console.log(`Response: ${response.status} ${response.statusText}`);
console.log(await response.json());

curl -X POST "$SIGNPLUS_URL/v1/signings" \
  -H "Authorization: Bearer $SIGNPLUS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "pageId": "123456",
    "signers": [
      {
        "email": "anna@example.com",
        "name": "Anna Tamm"
      },
      {
        "group": "finance-team"
      },
      {
        "email": "jaan@example.com",
        "name": "Jaan Kask",
        "role": "viewer"
      }
    ],
    "name": "Expense policy 2026",
    "message": "Please sign by Friday",
    "deadline": "2026-12-31T17:00:00+02:00"
  }'

{
  "jobId": "7c1e9a0f3b2d4c5e6f7a8b9c",
  "status": "queued",
  "pageId": "123456",
  "statusUrl": "/v1/pages/123456/signing-jobs/7c1e9a0f3b2d4c5e6f7a8b9c"
}

export default async function () {
    return http.get('signplus', '/v1/pages/123456/signing-jobs/7c1e9a0f3b2d4c5e6f7a8b9c');
}

import { fetch } from '@forge/api';
import { signplusToken } from './signplus';

const response = await fetch(`${process.env.SIGNPLUS_URL}/v1/pages/123456/signing-jobs/7c1e9a0f3b2d4c5e6f7a8b9c`, {
  headers: {
    'Authorization': `Bearer ${await signplusToken()}`,
    'Accept': 'application/json'
  }
});

console.log(`Response: ${response.status} ${response.statusText}`);
console.log(await response.json());

curl "$SIGNPLUS_URL/v1/pages/123456/signing-jobs/7c1e9a0f3b2d4c5e6f7a8b9c" \
  -H "Authorization: Bearer $SIGNPLUS_TOKEN"

{
  "id": "7c1e9a0f3b2d4c5e6f7a8b9c",
  "documentName": "Expense policy 2026",
  "status": "started",
  "reference": "a3f9c2d1e4b5a6978877665544332211",
  "created": "2026-10-02T09:00:00.000Z",
  "updated": "2026-10-02T09:01:12.000Z"
}

export default async function () {
    return http.get('signplus', '/v1/pages/123456/status');
}

import { fetch } from '@forge/api';
import { signplusToken } from './signplus';

const response = await fetch(`${process.env.SIGNPLUS_URL}/v1/pages/123456/status`, {
  headers: {
    'Authorization': `Bearer ${await signplusToken()}`,
    'Accept': 'application/json'
  }
});

console.log(`Response: ${response.status} ${response.statusText}`);
console.log(await response.json());

curl "$SIGNPLUS_URL/v1/pages/123456/status" \
  -H "Authorization: Bearer $SIGNPLUS_TOKEN"

{
  "pageId": "123456",
  "spaceId": "98307",
  "pageVersion": 8,
  "state": "signed-modified",
  "signings": [
    {
      "reference": "a3f9c2d1e4b5a6978877665544332211",
      "status": "completed",
      "documentName": "Expense policy 2026",
      "signedVersion": 7,
      "modifiedSinceSigning": true,
      "created": "2026-10-02T09:01:12.000Z",
      "updated": "2026-10-03T11:30:00.000Z"
    }
  ],
  "nextCursor": "eyJpZCI6..."
}

export default async function () {
    return http.get('signplus', '/v1/signings/a3f9c2d1e4b5a6978877665544332211', { query: { pageId: '123456' } });
}

import { fetch } from '@forge/api';
import { signplusToken } from './signplus';

const response = await fetch(`${process.env.SIGNPLUS_URL}/v1/signings/a3f9c2d1e4b5a6978877665544332211?pageId=123456`, {
  headers: {
    'Authorization': `Bearer ${await signplusToken()}`,
    'Accept': 'application/json'
  }
});

console.log(`Response: ${response.status} ${response.statusText}`);
console.log(await response.json());

curl "$SIGNPLUS_URL/v1/signings/a3f9c2d1e4b5a6978877665544332211?pageId=123456" \
  -H "Authorization: Bearer $SIGNPLUS_TOKEN"

{
  "reference": "a3f9c2d1e4b5a6978877665544332211",
  "spaceId": "98307",
  "spaceName": "Human Resources",
  "spaceUrl": "https://your-site.atlassian.net/wiki/spaces/HR",
  "spaceIconUrl": "https://your-site.atlassian.net/wiki/download/attachments/.../space-icon",
  "pageId": "123456",
  "pageName": "Expense policy",
  "pageVersion": 7,
  "pageHash": "8f14e4...",
  "initiatorAccountId": "5f1b...",
  "signingStatus": "pending",
  "documentName": "Expense policy 2026",
  "documentType": "pdf",
  "progress": {
    "total": 1204,
    "required": 1203,
    "signed": 911,
    "declined": 2
  },
  "groups": [
    {
      "id": "0f6a...",
      "name": "finance-team",
      "role": "signer",
      "members": 1202
    }
  ],
  "created": "2026-10-02T09:01:12.000Z",
  "updated": "2026-10-02T14:20:45.000Z"
}

export default async function () {
    return http.get('signplus', '/v1/signings/a3f9c2d1e4b5a6978877665544332211/signers', { query: { pageId: '123456', status: 'pending' } });
}

import { fetch } from '@forge/api';
import { signplusToken } from './signplus';

const response = await fetch(`${process.env.SIGNPLUS_URL}/v1/signings/a3f9c2d1e4b5a6978877665544332211/signers?pageId=123456&status=pending`, {
  headers: {
    'Authorization': `Bearer ${await signplusToken()}`,
    'Accept': 'application/json'
  }
});

console.log(`Response: ${response.status} ${response.statusText}`);
console.log(await response.json());

curl "$SIGNPLUS_URL/v1/signings/a3f9c2d1e4b5a6978877665544332211/signers?pageId=123456&status=pending" \
  -H "Authorization: Bearer $SIGNPLUS_TOKEN"

{
  "signers": [
    {
      "external_id": "5f1b...",
      "name": "Mari Maasikas",
      "email": "mari.maasikas@example.com",
      "role": "signer",
      "status": "pending",
      "group": "finance-team"
    }
  ],
  "nextCursor": "eyJpZCI6..."
}

export default async function () {
    return http.get('signplus', '/v1/signings', { query: { pageId: '123456' } });
}

import { fetch } from '@forge/api';
import { signplusToken } from './signplus';

const response = await fetch(`${process.env.SIGNPLUS_URL}/v1/signings?pageId=123456`, {
  headers: {
    'Authorization': `Bearer ${await signplusToken()}`,
    'Accept': 'application/json'
  }
});

console.log(`Response: ${response.status} ${response.statusText}`);
console.log(await response.json());

curl "$SIGNPLUS_URL/v1/signings?pageId=123456" \
  -H "Authorization: Bearer $SIGNPLUS_TOKEN"

{
  "signings": [
    {
      "reference": "a3f9c2d1e4b5a6978877665544332211",
      "spaceId": "98307",
      "spaceName": "Human Resources",
      "spaceUrl": "https://your-site.atlassian.net/wiki/spaces/HR",
      "spaceIconUrl": "https://your-site.atlassian.net/wiki/download/attachments/.../space-icon",
      "pageId": "123456",
      "pageName": "Expense policy",
      "pageVersion": 7,
      "pageHash": "8f14e4...",
      "initiatorAccountId": "5f1b...",
      "signingStatus": "pending",
      "documentName": "Expense policy 2026",
      "documentType": "pdf",
      "progress": {
        "total": 1204,
        "required": 1203,
        "signed": 911,
        "declined": 2
      },
      "groups": [
        {
          "id": "0f6a...",
          "name": "finance-team",
          "role": "signer",
          "members": 1202
        }
      ],
      "created": "2026-10-02T09:01:12.000Z",
      "updated": "2026-10-02T14:20:45.000Z"
    }
  ],
  "nextCursor": "eyJpZCI6..."
}

export default async function () {
    return http.delete('signplus', '/v1/signings/a3f9c2d1e4b5a6978877665544332211', { query: { pageId: '123456' } });
}

import { fetch } from '@forge/api';
import { signplusToken } from './signplus';

const response = await fetch(`${process.env.SIGNPLUS_URL}/v1/signings/a3f9c2d1e4b5a6978877665544332211?pageId=123456`, {
  method: 'DELETE',
  headers: {
    'Authorization': `Bearer ${await signplusToken()}`,
    'Accept': 'application/json'
  }
});

console.log(`Response: ${response.status} ${response.statusText}`);
console.log(await response.json());

curl -X DELETE "$SIGNPLUS_URL/v1/signings/a3f9c2d1e4b5a6978877665544332211?pageId=123456" \
  -H "Authorization: Bearer $SIGNPLUS_TOKEN"

{
  "reference": "a3f9c2d1e4b5a6978877665544332211",
  "status": "cancelled"
}

PDF operations

export default async function () {
    return http.post('signplus', '/v1/pages/123456/pdf', {
        name: 'Supplier agreement',
        includeAttachments: true,
    }, { query: { inline: 'true' } });
}

import { fetch } from '@forge/api';
import { signplusToken } from './signplus';

var bodyData = `{
  "name": "Supplier agreement",
  "includeAttachments": true
}`;

const response = await fetch(`${process.env.SIGNPLUS_URL}/v1/pages/123456/pdf?inline=true`, {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${await signplusToken()}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: bodyData
});

console.log(`Response: ${response.status} ${response.statusText}`);
console.log(await response.json());

curl -X POST "$SIGNPLUS_URL/v1/pages/123456/pdf?inline=true" \
  -H "Authorization: Bearer $SIGNPLUS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Supplier agreement",
    "includeAttachments": true
  }'

{
  "attachmentId": "att98765",
  "fileName": "Supplier agreement.pdf",
  "downloadUrl": "https://your-site.atlassian.net/wiki/download/attachments/...",
  "sizeBytes": 184320,
  "contentBase64": "JVBERi0xLjcK..."
}

export default async function () {
    return http.get('signplus', '/v1/pages/123456/pdf/att98765');
}

import { fetch } from '@forge/api';
import { signplusToken } from './signplus';

const response = await fetch(`${process.env.SIGNPLUS_URL}/v1/pages/123456/pdf/att98765`, {
  headers: {
    'Authorization': `Bearer ${await signplusToken()}`,
    'Accept': 'application/json'
  }
});

console.log(`Response: ${response.status} ${response.statusText}`);
console.log(await response.json());

curl "$SIGNPLUS_URL/v1/pages/123456/pdf/att98765" \
  -H "Authorization: Bearer $SIGNPLUS_TOKEN"

{
  "attachmentId": "att98765",
  "fileName": "Supplier agreement.pdf",
  "mediaType": "application/pdf",
  "sizeBytes": 184320,
  "downloadUrl": "https://your-site.atlassian.net/wiki/download/attachments/...",
  "contentBase64": "JVBERi0xLjcK..."
}

export default async function () {
    return http.get('signplus', '/v1/signings/a3f9c2d1e4b5a6978877665544332211/document', { query: { pageId: '123456' } });
}

import { fetch } from '@forge/api';
import { signplusToken } from './signplus';

const response = await fetch(`${process.env.SIGNPLUS_URL}/v1/signings/a3f9c2d1e4b5a6978877665544332211/document?pageId=123456`, {
  headers: {
    'Authorization': `Bearer ${await signplusToken()}`,
    'Accept': 'application/json'
  }
});

console.log(`Response: ${response.status} ${response.statusText}`);
console.log(await response.json());

curl "$SIGNPLUS_URL/v1/signings/a3f9c2d1e4b5a6978877665544332211/document?pageId=123456" \
  -H "Authorization: Bearer $SIGNPLUS_TOKEN"

{
  "reference": "a3f9c2d1e4b5a6978877665544332211",
  "attachmentId": "att98770",
  "fileName": "Supplier agreement.pdf",
  "mediaType": "application/pdf",
  "sizeBytes": 201733,
  "downloadUrl": "https://your-site.atlassian.net/wiki/download/attachments/...",
  "contentBase64": "JVBERi0xLjcK..."
}

More on the operations

Who a signer is

A signer is a person or a group, with role signer (the default) or viewer. A person needs both email and name; one without a name is refused with 400.

[
  { "email": "anna@example.com", "name": "Anna Tamm", "role": "signer" },
  { "group": "finance-team", "role": "signer" },
  { "groupId": "0f6a1b2c-...", "role": "viewer" }
]

• A person is named by email address. An address that belongs to a Confluence user who can view the page adds that user; anyone else signs as an external signer. Confluence cannot be searched by address, so the match is made by name and confirmed against the account’s own address, for up to 100 addresses in one request. Past 100, every address signs as an external signer, and an external signer cannot be named in a view restriction.
• A group is named by its name or its id, and every member is invited with the group’s role. A member Confluence gives no address for cannot be invited, and the job’s message says how many. The service account may name only groups it belongs to, as a person in the panel may. Any other group answers 403 before anything is queued.
• spaceId is not a field. SignPlus asks Confluence which space the page is in, so a caller cannot choose which space’s rules apply.
• Text is cleaned and held to a length. Control characters and the Unicode controls that reorder text are removed from names, the document name and the message. A document name is at most 200 characters and loses \ / : * ? " < > |, because it becomes a file name. A message is at most 2,000 characters, a name 200.

What a page’s state means

The newest signing decides it, by the byline’s hash.

Reading the people on a signing

A reply can come back shorter than limit when reading more would outrun the request’s time, so only an absent nextCursor means you have everyone. Ask about at most 1,000 people by email or accountId in one request.

This is the one place SignPlus returns a signer’s email address, to an account that can view the page, because chasing the people who have not signed needs it. The panel on the page never sends one to a browser.

Cancelling and deleting

• A running signing is cancelled: removed from Dokobit for every signer, with its page restrictions lifted.
• A finished signing is deleted: removed from Dokobit for every signer, with its edit lock lifted, and its record goes.

The signed file stays attached to the page either way, and the same permissions apply as in the panel: see cancelling or deleting a signing. A 502 means Dokobit could not be reached or the page restrictions could not be put back. The record stays, and sending the request again is safe.

Errors

{
  "error": "At least one signer is required in \"signers\"."
}

In Code Studio, a status of 400 or more throws HttpError; its status is the code and its body the JSON above.

What the API never returns

• Dokobit tokens, for the document or a signer. The reference is part of a SHA-256 of the document token and cannot be reversed.
• A stored document. None is stored; the PDF endpoints read it from the page.

Common problems

When you ask for help with a signing, quote its reference: it identifies the signing and reveals nothing about its contents.

Common questions

How does the SignPlus REST API authenticate?

With an OAuth 2.0 access token from an Atlassian service account, sent as Authorization: Bearer <token>. SignPlus issues no API keys of its own, and a token lasts 60 minutes.

Where is the SignPlus API address?

In SignPlus's global settings, under API access, then API address. Atlassian creates it for each installation, so every site has its own.

Does starting a signing through the API return the signing at once?

No. POST /v1/signings answers 202 Accepted with a job id. Follow the job, or the completion webhook, for the signing's reference.

Can I get the signed PDF through the API?

Yes, with GET /v1/signings/{reference}/document?pageId= once everyone has signed. Before that it answers 409.

How many requests can the API take?

60 a minute for each account, answered with 429 past that. A request body is at most 2MB and a request at most 55 seconds.

Related

• Automation and webhooks
• Sign a page
• Code Studio: requests to other systems
• Privacy and data handling

A problem or a question? Write to support@oktul.com or open a request in the Help Center (opens in a new tab).