Desenvolvedores

Quickstart — chame o API do seu servidor

Reivindicar uma sandbox, armazenar a chave `esk_test_`, confirmá-la, criar um documento a partir de um modelo e enviá-lo. Os tokens de sessão de assinatura usam a mesma chave. Webhooks são registrados no aplicativo de administração.

Antes de começar

Você precisa de um terminal com `curl` e `jq`, além de uma caixa de entrada de e-mail que você controla. A chave da sandbox é `esk_test_…`. Uma chave de produção é `esk_live_…`. Envie-o como `Autorização: Portador`. O inquilino vem da chave, portanto não envie `x-tenant-id`.

Uma chave sandbox inclui `integrations:zapier` e `signing:write`. O upload, o assistente de envelope e o registro webhook usam a sessão de administrador após você entrar. Seu servidor usa a chave para as chamadas abaixo.

Quatro chamadas de servidor, depois um webhook no aplicativo de administração

  1. 1

    Reivindicar sua caixa de areia

    POST /api/auth/register with `mode: sandbox`. The response includes a full `esk_test_…` key, shown once, plus `demoCustomerId`. When seeding succeeds it also includes `sampleTemplateId`.

  2. 2

    Confirme a chave

    GET /api/v1/zapier/auth/test with the key. Expected output: HTTP 200 and `{ success: true, data: { tenantId, tenantName, zapierEnabled: true } }`.

  3. 3

    Crie um documento e envie-o

    POST /api/v1/zapier/actions/create-from-template with `sampleTemplateId`, then POST /api/v1/zapier/actions/send-for-signing with the returned `documentId`. The signer receives the link by email.

  4. 4

    Registre um webhook no Admin

    Faça login e abra Admin → Desenvolvedor → Webhooks. Salve o segredo de assinatura. As entregas usam `X-Endorsed-Signature`. As etapas de verificação estão no guia webhooks. Inspecione as tentativas em Admin → Desenvolvedor → Console.

Etapa 1 – reivindicar uma sandbox

Pré-requisitos: um endereço de e-mail e uma senha com mais de 8 caracteres. Saída esperada: HTTP 201 com `data.sandbox.apiKey` iniciando `esk_test_`.

bash
curl -sS -X POST https://api.endorsedsign.com/api/auth/register \
  -H 'Content-Type: application/json' \
  -d '{
    "tenantName": "Acme Dev Sandbox",
    "adminEmail": "you@acme.example",
    "password": "your-strong-password",
    "mode": "sandbox"
  }' | tee sandbox.json | jq '.data.sandbox'

# → {
#     "apiKey": "esk_test_…",
#     "keyPrefix": "esk_test_…",
#     "keyId": "…",
#     "scopes": ["signing:write", "integrations:zapier", …],
#     "demoCustomerId": "sandbox-signer-acme-dev-sandbox",
#     "demoCustomerName": "Sandbox Signer",
#     "sampleTemplateId": "…",
#     "expiresAt": "2026-…"
#   }

export ENDORSED_API_KEY="$(jq -r '.data.sandbox.apiKey' sandbox.json)"
export ENDORSED_TEMPLATE_ID="$(jq -r '.data.sandbox.sampleTemplateId // empty' sandbox.json)"

Armazene a chave no gerenciador de segredos do servidor. A verificação de e-mail bloqueia o console administrativo. A chave funciona para as chamadas desta página assim que é emitida.

Etapa 2 — confirme a chave

Pré-requisitos: `$ENDORSED_API_KEY` do passo 1. A chave do sandbox já possui `integrations:zapier`. Saída esperada: HTTP 200 e o nome do seu locatário.

bash
curl -sS https://api.endorsedsign.com/api/v1/zapier/auth/test \
  -H "Authorization: Bearer $ENDORSED_API_KEY" \
  | jq '{ success, tenantId: .data.tenantId, tenantName: .data.tenantName, zapierEnabled: .data.zapierEnabled }'

Uma chave ausente ou malformada é 401. Uma chave válida sem `integrations:zapier` é 403. Não envie `X-Data-Mode`: `esk_test_` já seleciona dados de teste.

Etapa 3 — crie um documento a partir do modelo sandbox e envie-o

Pré-requisitos: `$ENDORSED_API_KEY` e um `$ENDORSED_TEMPLATE_ID` não vazio. Se `sampleTemplateId` for nulo, crie um modelo no aplicativo de administração e cole seu ID. Saída esperada: HTTP 201 com `data.documentId` e, em seguida, uma resposta de envio com `status: "link-sent"`.

bash
curl -sS -X POST https://api.endorsedsign.com/api/v1/zapier/actions/create-from-template \
  -H "Authorization: Bearer $ENDORSED_API_KEY" \
  -H 'Content-Type: application/json' \
  -d "{
    \"templateId\": \"$ENDORSED_TEMPLATE_ID\",
    \"recipientEmail\": \"you@acme.example\",
    \"recipientName\": \"Sandbox Signer\"
  }" | tee created.json | jq '.data | { documentId, customerId, status }'

export ENDORSED_DOCUMENT_ID="$(jq -r '.data.documentId' created.json)"

curl -sS -X POST https://api.endorsedsign.com/api/v1/zapier/actions/send-for-signing \
  -H "Authorization: Bearer $ENDORSED_API_KEY" \
  -H 'Content-Type: application/json' \
  -d "{
    \"documentId\": \"$ENDORSED_DOCUMENT_ID\",
    \"channel\": \"email\",
    \"subject\": \"Please sign\"
  }" | jq '.data | { documentId, status, channel, shareLinkExpiresAt }'

O link de assinatura é enviado por e-mail para `recipientEmail`. A resposta JSON carrega o ID do documento, o status e a expiração do link. Abra o e-mail para finalizar a assinatura e assista `document.signed` em um webhook que você registrou no Admin.

Criar um token de sessão de assinatura

Pré-requisitos: `$ENDORSED_API_KEY` com `signing:write` (incluído na chave sandbox) e um ID de sessão de assinatura de uma sessão que você já criou. Saída esperada: HTTP 201 com um token `st_…` único.

bash
curl -sS -X POST "https://api.endorsedsign.com/api/v1/signing-sessions/$ENDORSED_SESSION_ID/tokens" \
  -H "Authorization: Bearer $ENDORSED_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{ "scope": "embed", "ttl_seconds": 300 }' \
  | jq '{ token, expires_at, scope }'

Hand `st_…` para incorporar o navegador. Mantenha `esk_…` no servidor. As instruções de resgate estão na página de incorporação do Elements.

Quando algo dá errado

Pronto para ir mais fundo?

Depois de ter um documento assinado de ponta a ponta, conecte-se às áreas de superfície abaixo para a próxima parte da integração.

REST API referênciaWebhook contrato + assinaturas