Sealeo API Documentation

Welcome to the Sealeo API by AppLeo, LLC. This API provides programmatic access to Sealeo's document signing platform. Use it to integrate e-signatures into your applications, automate document workflows, and build custom signing solutions.

Authentication

All API requests require authentication via an API key. Include your API key in the Authorization header:

Authorization: YOUR_API_KEY

Base URL

All API endpoints are relative to:

https://sealeo.app-leo.us/api/v2

Response Codes

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Document

GET /document/{documentId} Get document

Returns a document given an ID

Parameters

Name	Type	In	Required
documentId	number	path	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.get({
    documentId: 6150.61,
  });

  console.log(result);
}

run();

GET /document Find documents

Find documents based on a search criteria

Parameters

Name	Type	In	Required
query	string	query	No
page	number	query	No
perPage	number	query	No
templateId	number	query	No
source	string	query	No
status	string	query	No
folderId	string	query	No
orderByColumn	string	query	No
orderByDirection	string	query	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.find({});

  console.log(result);
}

run();

POST /document/create Create document

Create a document using form data.

Request Body (multipart/form-data)

Property	Type	Required
payload	object	Yes
file	string	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";
import { openAsBlob } from "node:fs";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.create({
    payload: {
      title: "<value>",
    },
    file: await openAsBlob("example.file"),
  });

  console.log(result);
}

run();

POST /document/update Update document

Request Body (application/json)

Property	Type	Required
documentId	number	Yes
data	object	No
meta	object	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.update({
    documentId: 3428.95,
  });

  console.log(result);
}

run();

POST /document/delete Delete document

Request Body (application/json)

Property	Type	Required
documentId	number	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.delete({
    documentId: 3963.4,
  });

  console.log(result);
}

run();

POST /document/duplicate Duplicate document

Request Body (application/json)

Property	Type	Required
documentId	number	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.duplicate({
    documentId: 5285.3,
  });

  console.log(result);
}

run();

POST /document/distribute Distribute document

Send the document out to recipients based on your distribution method

Request Body (application/json)

Property	Type	Required
documentId	number	Yes
meta	object	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.distribute({
    documentId: 7548.74,
  });

  console.log(result);
}

run();

POST /document/redistribute Redistribute document

Redistribute the document to the provided recipients who have not actioned the document. Will use the distribution method set in the document

Request Body (application/json)

Property	Type	Required
documentId	number	Yes
recipients	array[number]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.redistribute({
    documentId: 9084.69,
    recipients: [
      6011.8,
      4441.56,
      4251.15,
    ],
  });

  console.log(result);
}

run();

GET /document/{documentId}/download Download document

Parameters

Name	Type	In	Required
documentId	number	path	Yes
version	string	query	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.download({
    documentId: 5396.97,
  });

  console.log(result);
}

run();

GET /document/{documentId}/download-beta Download document (beta)

Get a pre-signed download URL for the original or signed version of a document

Parameters

Name	Type	In	Required
documentId	number	path	Yes
version	string	query	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.document.documentDownload({
    documentId: 9550.11,
  });

  console.log(result);
}

run();

POST /document/create/beta Create document

You will need to upload the PDF to the provided URL returned. Note: Once V2 API is released, this will be removed since we will allow direct uploads, instead of using an upload URL.

Request Body (application/json)

Property	Type	Required
title	string	Yes
externalId	string	No
visibility	string	No
globalAccessAuth	array[string]	No
globalActionAuth	array[string]	No
formValues	object	No
folderId	string	No
recipients	array[object]	No
attachments	array[object]	No
meta	object	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.createV0({
    title: "<value>",
  });

  console.log(result);
}

run();

POST /document/attachment/create Create attachment

Create a new attachment for a document

Request Body (application/json)

Property	Type	Required
documentId	number	Yes
data	object	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.attachments.create({
    documentId: 7014.36,
    data: {
      label: "<value>",
      data: "https://cheerful-bourgeoisie.org/",
    },
  });

  console.log(result);
}

run();

POST /document/attachment/update Update attachment

Update an existing attachment

Request Body (application/json)

Property	Type	Required
id	string	Yes
data	object	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.attachments.update({
    id: "<id>",
    data: {
      label: "<value>",
      data: "https://tinted-ceramics.biz",
    },
  });

  console.log(result);
}

run();

POST /document/attachment/delete Delete attachment

Delete an attachment from a document

Request Body (application/json)

Property	Type	Required
id	string	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.attachments.delete({
    id: "<id>",
  });

  console.log(result);
}

run();

GET /document/attachment Find attachments

Find all attachments for a document

Parameters

Name	Type	In	Required
documentId	number	query	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.attachments.find({
    documentId: 965.17,
  });

  console.log(result);
}

run();

Document Fields

GET /document/field/{fieldId} Get document field

Returns a single field. If you want to retrieve all the fields for a document, use the "Get Document" endpoint.

Parameters

Name	Type	In	Required
fieldId	number	path	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.fields.get({
    fieldId: 6077.81,
  });

  console.log(result);
}

run();

POST /document/field/create Create document field

Create a single field for a document.

Request Body (application/json)

Property	Type	Required
documentId	number	Yes
field	any	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.fields.create({
    documentId: 8001.93,
    field: {
      type: "NAME",
      recipientId: 2564.68,
      pageNumber: 791.77,
      pageX: 7845.22,
      pageY: 6843.16,
      width: 3932.15,
      height: 8879.89,
    },
  });

  console.log(result);
}

run();

POST /document/field/create-many Create document fields

Create multiple fields for a document.

Request Body (application/json)

Property	Type	Required
documentId	number	Yes
fields	array[any]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.fields.createMany({
    documentId: 6257.51,
    fields: [
      {
        type: "FREE_SIGNATURE",
        recipientId: 679.35,
        pageNumber: 5914.59,
        pageX: 7253.11,
        pageY: 8426.91,
        width: 8995.55,
        height: 9808.97,
      },
    ],
  });

  console.log(result);
}

run();

POST /document/field/update Update document field

Update a single field for a document.

Request Body (application/json)

Property	Type	Required
documentId	number	Yes
field	any	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.fields.update({
    documentId: 5956.26,
    field: {
      type: "FREE_SIGNATURE",
      id: 6955.16,
    },
  });

  console.log(result);
}

run();

POST /document/field/update-many Update document fields

Update multiple fields for a document.

Request Body (application/json)

Property	Type	Required
documentId	number	Yes
fields	array[any]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.fields.updateMany({
    documentId: 9317.43,
    fields: [],
  });

  console.log(result);
}

run();

POST /document/field/delete Delete document field

Request Body (application/json)

Property	Type	Required
fieldId	number	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.fields.delete({
    fieldId: 4748.27,
  });

  console.log(result);
}

run();

Document Recipients

GET /document/recipient/{recipientId} Get document recipient

Returns a single recipient. If you want to retrieve all the recipients for a document, use the "Get Document" endpoint.

Parameters

Name	Type	In	Required
recipientId	number	path	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.recipients.get({
    recipientId: 874.3,
  });

  console.log(result);
}

run();

POST /document/recipient/create Create document recipient

Create a single recipient for a document.

Request Body (application/json)

Property	Type	Required
documentId	number	Yes
recipient	object	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.recipients.create({
    documentId: 3058.31,
    recipient: {
      email: "Ila.Steuber@yahoo.com",
      name: "<value>",
      role: "ASSISTANT",
    },
  });

  console.log(result);
}

run();

POST /document/recipient/create-many Create document recipients

Create multiple recipients for a document.

Request Body (application/json)

Property	Type	Required
documentId	number	Yes
recipients	array[object]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.recipients.createMany({
    documentId: 9983.95,
    recipients: [
      {
        email: "Roosevelt_Baumbach@yahoo.com",
        name: "<value>",
        role: "CC",
      },
    ],
  });

  console.log(result);
}

run();

POST /document/recipient/update Update document recipient

Update a single recipient for a document.

Request Body (application/json)

Property	Type	Required
documentId	number	Yes
recipient	object	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.recipients.update({
    documentId: 7045.62,
    recipient: {
      id: 2224.05,
    },
  });

  console.log(result);
}

run();

POST /document/recipient/update-many Update document recipients

Update multiple recipients for a document.

Request Body (application/json)

Property	Type	Required
documentId	number	Yes
recipients	array[object]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.recipients.updateMany({
    documentId: 3189.76,
    recipients: [],
  });

  console.log(result);
}

run();

POST /document/recipient/delete Delete document recipient

Request Body (application/json)

Property	Type	Required
recipientId	number	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.documents.recipients.delete({
    recipientId: 5490.43,
  });

  console.log(result);
}

run();

Embedding

POST /embedding/create-presign-token Create embedding presign token

Creates a presign token for embedding operations with configurable expiration time

Request Body (application/json)

Property	Type	Required
expiresIn	number	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.embedding.embeddingPresignCreateEmbeddingPresignToken({});

  console.log(result);
}

run();

POST /embedding/verify-presign-token Verify embedding presign token

Verifies a presign token for embedding operations and returns the associated API token

Request Body (application/json)

Property	Type	Required
token	string	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.embedding.embeddingPresignVerifyEmbeddingPresignToken({
    token: "<value>",
  });

  console.log(result);
}

run();

Envelope

GET /envelope/{envelopeId} Get envelope

Returns an envelope given an ID

Parameters

Name	Type	In	Required
envelopeId	string	path	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.get({
    envelopeId: "<id>",
  });

  console.log(result);
}

run();

POST /envelope/create Create envelope

Create an envelope using form data.

Request Body (multipart/form-data)

Property	Type	Required
payload	object	Yes
files	array[string]	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.create({
    payload: {
      title: "<value>",
      type: "TEMPLATE",
    },
  });

  console.log(result);
}

run();

POST /envelope/use Use envelope

Create a document envelope from a template envelope. Upload custom files to replace the template PDFs and map them to specific envelope items using identifiers.

Request Body (multipart/form-data)

Property	Type	Required
payload	object	Yes
files	array[string]	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.use({
    payload: {
      envelopeId: "<id>",
    },
  });

  console.log(result);
}

run();

POST /envelope/update Update envelope

Request Body (application/json)

Property	Type	Required
envelopeId	string	Yes
data	object	No
meta	object	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.update({
    envelopeId: "<id>",
  });

  console.log(result);
}

run();

POST /envelope/delete Delete envelope

Request Body (application/json)

Property	Type	Required
envelopeId	string	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.delete({
    envelopeId: "<id>",
  });

  console.log(result);
}

run();

POST /envelope/duplicate Duplicate envelope

Duplicate an envelope with all its settings

Request Body (application/json)

Property	Type	Required
envelopeId	string	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.duplicate({
    envelopeId: "<id>",
  });

  console.log(result);
}

run();

POST /envelope/distribute Distribute envelope

Send the envelope to recipients based on your distribution method

Request Body (application/json)

Property	Type	Required
envelopeId	string	Yes
meta	object	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.distribute({
    envelopeId: "<id>",
  });

  console.log(result);
}

run();

POST /envelope/redistribute Redistribute envelope

Redistribute the envelope to the provided recipients who have not actioned the envelope. Will use the distribution method set in the envelope

Request Body (application/json)

Property	Type	Required
envelopeId	string	Yes
recipients	array[number]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.redistribute({
    envelopeId: "<id>",
    recipients: [],
  });

  console.log(result);
}

run();

Envelope Attachments

GET /envelope/attachment Find attachments

Find all attachments for an envelope

Parameters

Name	Type	In	Required
envelopeId	string	query	Yes
token	string	query	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.attachments.find({
    envelopeId: "<id>",
  });

  console.log(result);
}

run();

POST /envelope/attachment/create Create attachment

Create a new attachment for an envelope

Request Body (application/json)

Property	Type	Required
envelopeId	string	Yes
data	object	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.attachments.create({
    envelopeId: "<id>",
    data: {
      label: "<value>",
      data: "https://lustrous-skeleton.info",
    },
  });

  console.log(result);
}

run();

POST /envelope/attachment/update Update attachment

Update an existing attachment

Request Body (application/json)

Property	Type	Required
id	string	Yes
data	object	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.attachments.update({
    id: "<id>",
    data: {
      label: "<value>",
      data: "https://tough-premier.biz",
    },
  });

  console.log(result);
}

run();

POST /envelope/attachment/delete Delete attachment

Delete an attachment from an envelope

Request Body (application/json)

Property	Type	Required
id	string	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.attachments.delete({
    id: "<id>",
  });

  console.log(result);
}

run();

Envelope Fields

GET /envelope/field/{fieldId} Get envelope field

Returns an envelope field given an ID

Parameters

Name	Type	In	Required
fieldId	number	path	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.fields.get({
    fieldId: 6981.76,
  });

  console.log(result);
}

run();

POST /envelope/field/create-many Create envelope fields

Create multiple fields for an envelope

Request Body (application/json)

Property	Type	Required
envelopeId	string	Yes
data	array[any]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.fields.createMany({
    envelopeId: "<id>",
    data: [],
  });

  console.log(result);
}

run();

POST /envelope/field/update-many Update envelope fields

Update multiple envelope fields for an envelope

Request Body (application/json)

Property	Type	Required
envelopeId	string	Yes
data	array[any]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.fields.updateMany({
    envelopeId: "<id>",
    data: [],
  });

  console.log(result);
}

run();

POST /envelope/field/delete Delete envelope field

Delete an envelope field

Request Body (application/json)

Property	Type	Required
fieldId	number	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.fields.delete({
    fieldId: 2481.37,
  });

  console.log(result);
}

run();

Envelope Items

POST /envelope/item/create-many Create envelope items

Create multiple envelope items for an envelope

Request Body (multipart/form-data)

Property	Type	Required
payload	object	Yes
files	array[string]	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.items.createMany({
    payload: {
      envelopeId: "<id>",
    },
  });

  console.log(result);
}

run();

POST /envelope/item/update-many Update envelope items

Update multiple envelope items for an envelope

Request Body (application/json)

Property	Type	Required
envelopeId	string	Yes
data	array[object]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.items.updateMany({
    envelopeId: "<id>",
    data: [],
  });

  console.log(result);
}

run();

POST /envelope/item/delete Delete envelope item

Delete an envelope item from an envelope

Request Body (application/json)

Property	Type	Required
envelopeId	string	Yes
envelopeItemId	string	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.items.delete({
    envelopeId: "<id>",
    envelopeItemId: "<id>",
  });

  console.log(result);
}

run();

GET /envelope/item/{envelopeItemId}/download Download an envelope item

Download an envelope item by its ID

Parameters

Name	Type	In	Required
envelopeItemId	string	path	Yes
version	string	query	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.items.download({
    envelopeItemId: "<id>",
  });

  console.log(result);
}

run();

Envelope Recipients

GET /envelope/recipient/{recipientId} Get envelope recipient

Returns an envelope recipient given an ID

Parameters

Name	Type	In	Required
recipientId	number	path	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.recipients.get({
    recipientId: 8771.72,
  });

  console.log(result);
}

run();

POST /envelope/recipient/create-many Create envelope recipients

Create multiple recipients for an envelope

Request Body (application/json)

Property	Type	Required
envelopeId	string	Yes
data	array[object]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.recipients.createMany({
    envelopeId: "<id>",
    data: [
      {
        email: "Ed16@yahoo.com",
        name: "<value>",
        role: "SIGNER",
      },
    ],
  });

  console.log(result);
}

run();

POST /envelope/recipient/update-many Update envelope recipients

Update multiple recipients for an envelope

Request Body (application/json)

Property	Type	Required
envelopeId	string	Yes
data	array[object]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.recipients.updateMany({
    envelopeId: "<id>",
    data: [
      {
        id: 8894.57,
      },
    ],
  });

  console.log(result);
}

run();

POST /envelope/recipient/delete Delete envelope recipient

Delete an envelope recipient

Request Body (application/json)

Property	Type	Required
recipientId	number	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.envelopes.recipients.delete({
    recipientId: 4834.93,
  });

  console.log(result);
}

run();

Folder

GET /folder Find folders

Find folders based on a search criteria

Parameters

Name	Type	In	Required
query	string	query	No
page	number	query	No
perPage	number	query	No
parentId	string	query	No
type	string	query	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.folders.find({});

  console.log(result);
}

run();

POST /folder/create Create new folder

Creates a new folder in your team

Request Body (application/json)

Property	Type	Required
name	string	Yes
parentId	string	No
type	string	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.folders.create({
    name: "<value>",
  });

  console.log(result);
}

run();

POST /folder/update Update folder

Updates an existing folder

Request Body (application/json)

Property	Type	Required
folderId	string	Yes
data	object	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.folders.update({
    folderId: "<id>",
    data: {},
  });

  console.log(result);
}

run();

POST /folder/delete Delete folder

Deletes an existing folder

Request Body (application/json)

Property	Type	Required
folderId	string	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.folders.delete({
    folderId: "<id>",
  });

  console.log(result);
}

run();

Template

GET /template Find templates

Find templates based on a search criteria

Parameters

Name	Type	In	Required
query	string	query	No
page	number	query	No
perPage	number	query	No
type	string	query	No
folderId	string	query	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.find({});

  console.log(result);
}

run();

GET /template/{templateId} Get template

Parameters

Name	Type	In	Required
templateId	number	path	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.get({
    templateId: 2128.54,
  });

  console.log(result);
}

run();

POST /template/create Create template

Create a new template

Request Body (multipart/form-data)

Property	Type	Required
payload	object	Yes
file	string	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";
import { openAsBlob } from "node:fs";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.create({
    payload: {
      title: "<value>",
    },
    file: await openAsBlob("example.file"),
  });

  console.log(result);
}

run();

POST /template/create/beta Create template

You will need to upload the PDF to the provided URL returned. Note: Once V2 API is released, this will be removed since we will allow direct uploads, instead of using an upload URL.

Request Body (application/json)

Property	Type	Required
title	string	Yes
folderId	string	No
externalId	string	No
visibility	string	No
globalAccessAuth	array[string]	No
globalActionAuth	array[string]	No
publicTitle	string	No
publicDescription	string	No
type	string	No
meta	object	No
attachments	array[object]	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.template.templateCreateTemplateTemporary({
    title: "<value>",
  });

  console.log(result);
}

run();

POST /template/update Update template

Request Body (application/json)

Property	Type	Required
templateId	number	Yes
data	object	No
meta	object	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.update({
    templateId: 9404.77,
  });

  console.log(result);
}

run();

POST /template/duplicate Duplicate template

Request Body (application/json)

Property	Type	Required
templateId	number	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.duplicate({
    templateId: 2490.16,
  });

  console.log(result);
}

run();

POST /template/delete Delete template

Request Body (application/json)

Property	Type	Required
templateId	number	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.delete({
    templateId: 536.89,
  });

  console.log(result);
}

run();

POST /template/use Use template

Use the template to create a document

Request Body (application/json)

Property	Type	Required
templateId	number	Yes
recipients	array[object]	Yes
distributeDocument	boolean	No
customDocumentDataId	string	No
customDocumentData	array[object]	No
folderId	string	No
prefillFields	array[any]	No
override	object	No
attachments	array[object]	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.use({
    templateId: 7392.96,
    recipients: [],
  });

  console.log(result);
}

run();

POST /template/direct/create Create direct link

Create a direct link for a template

Request Body (application/json)

Property	Type	Required
templateId	number	Yes
directRecipientId	number	No

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.directLink.create({
    templateId: 5094.31,
  });

  console.log(result);
}

run();

POST /template/direct/delete Delete direct link

Delete a direct link for a template

Request Body (application/json)

Property	Type	Required
templateId	number	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.directLink.delete({
    templateId: 9950.03,
  });

  console.log(result);
}

run();

POST /template/direct/toggle Toggle direct link

Enable or disable a direct link for a template

Request Body (application/json)

Property	Type	Required
templateId	number	Yes
enabled	boolean	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.directLink.toggle({
    templateId: 6583.54,
    enabled: false,
  });

  console.log(result);
}

run();

Template Fields

POST /template/field/create Create template field

Create a single field for a template.

Request Body (application/json)

Property	Type	Required
templateId	number	Yes
field	any	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.fields.create({
    templateId: 1203.71,
    field: {
      type: "DATE",
      recipientId: 2738.54,
      pageNumber: 5735.12,
      pageX: 2936.28,
      pageY: 8594.41,
      width: 7589.39,
      height: 3122.23,
    },
  });

  console.log(result);
}

run();

GET /template/field/{fieldId} Get template field

Returns a single field. If you want to retrieve all the fields for a template, use the "Get Template" endpoint.

Parameters

Name	Type	In	Required
fieldId	number	path	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.fields.get({
    fieldId: 1152.82,
  });

  console.log(result);
}

run();

POST /template/field/create-many Create template fields

Create multiple fields for a template.

Request Body (application/json)

Property	Type	Required
templateId	number	Yes
fields	array[any]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.fields.createMany({
    templateId: 586.2,
    fields: [
      {
        type: "SIGNATURE",
        recipientId: 6990.12,
        pageNumber: 3472.45,
        pageX: 4747.87,
        pageY: 1673.94,
        width: 7215.37,
        height: 9417.43,
      },
    ],
  });

  console.log(result);
}

run();

POST /template/field/update Update template field

Update a single field for a template.

Request Body (application/json)

Property	Type	Required
templateId	number	Yes
field	any	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.fields.update({
    templateId: 5083.07,
    field: {
      type: "TEXT",
      id: 1792.29,
    },
  });

  console.log(result);
}

run();

POST /template/field/update-many Update template fields

Update multiple fields for a template.

Request Body (application/json)

Property	Type	Required
templateId	number	Yes
fields	array[any]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.fields.updateMany({
    templateId: 3969.1,
    fields: [
      {
        type: "DROPDOWN",
        id: 2460.72,
      },
    ],
  });

  console.log(result);
}

run();

POST /template/field/delete Delete template field

Request Body (application/json)

Property	Type	Required
fieldId	number	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.fields.delete({
    fieldId: 7996.49,
  });

  console.log(result);
}

run();

Template Recipients

GET /template/recipient/{recipientId} Get template recipient

Returns a single recipient. If you want to retrieve all the recipients for a template, use the "Get Template" endpoint.

Parameters

Name	Type	In	Required
recipientId	number	path	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
404 Not found
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.recipients.get({
    recipientId: 9436.42,
  });

  console.log(result);
}

run();

POST /template/recipient/create Create template recipient

Create a single recipient for a template.

Request Body (application/json)

Property	Type	Required
templateId	number	Yes
recipient	object	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.recipients.create({
    templateId: 5712.95,
    recipient: {
      email: "Gerhard88@yahoo.com",
      name: "<value>",
      role: "SIGNER",
    },
  });

  console.log(result);
}

run();

POST /template/recipient/create-many Create template recipients

Create multiple recipients for a template.

Request Body (application/json)

Property	Type	Required
templateId	number	Yes
recipients	array[object]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.recipients.createMany({
    templateId: 5642.48,
    recipients: [],
  });

  console.log(result);
}

run();

POST /template/recipient/update Update template recipient

Update a single recipient for a template.

Request Body (application/json)

Property	Type	Required
templateId	number	Yes
recipient	object	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.recipients.update({
    templateId: 2984.61,
    recipient: {
      id: 8617.99,
    },
  });

  console.log(result);
}

run();

POST /template/recipient/update-many Update template recipients

Update multiple recipients for a template.

Request Body (application/json)

Property	Type	Required
templateId	number	Yes
recipients	array[object]	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.recipients.updateMany({
    templateId: 5597.58,
    recipients: [
      {
        id: 1630.42,
      },
    ],
  });

  console.log(result);
}

run();

POST /template/recipient/delete Delete template recipient

Request Body (application/json)

Property	Type	Required
recipientId	number	Yes

Responses

200 Successful response
400 Invalid input data
401 Authorization not provided
403 Insufficient access
500 Internal server error

Example (TypeScript)

import { Sealeo } from "@sealeo/sdk-typescript";

const sealeo = new Sealeo({
  apiKey: process.env["SEALEO_API_KEY"] ?? "",
});

async function run() {
  const result = await sealeo.templates.recipients.delete({
    recipientId: 312.69,
  });

  console.log(result);
}

run();