# APISign [Health: Active]

**Category:** 🤝 Agreements & Coordination  
**Repository:** https://github.com/wes/apisign-mcp  
**GitHub Stars:** 0  
**Views:** 1  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/apisign

## Description
Send documents for legally binding e-signature and manage the reusable templates behind them.

## Tools
Capabilities this server exposes over MCP:

- **template_list** — List all templates in the organization.
- **template_get** — Fetch one template by ID, with its content and field definitions.
- **template_create** — Create a blank template from a name and optional Markdown.
- **template_update** — Change a template's name, content, or fields.
- **template_upload** — Convert a base64-encoded DOCX/DOC into a template.
- **template_archive** — Soft-delete a template.
- **contract_list** — List contracts, optionally filtered by status.
- **contract_get** — Fetch one contract, including every signer and their status.
- **contract_create** — Create a contract from a template or from raw content, with signers.
- **contract_update** — Edit a draft contract's details or signers. Drafts only.
- **contract_send** — Send a contract for signing. Charges your balance and emails the signers.
- **contract_cancel** — Cancel a draft or sent contract.

## Claude Desktop Quick Installation
Remote MCP endpoint (confidence: high). Install path detected from listing signals. Add as a URL/SSE server in your client:

```json
"mcpServers": {
  "apisign": {
    "url": "https://apisign.io/mcp"
  }
}
```

## Documentation

## What the APISign MCP server does

The APISign MCP server gives an AI agent access to an organization's e-signature workflow.

Templates can be listed, inspected, created, edited, uploaded from base64-encoded DOCX or DOC files, and archived. Contracts can be listed with an optional status filter and retrieved with signer identities and signing states. Agents can also create contracts, change draft details or signers, send documents for signature, and cancel drafts or sent contracts.

The service is scoped to the organization associated with the API key. Sending a contract emails its signers and charges the account balance, so write access should be granted deliberately.

## How it works

The APISign MCP server is hosted at `https://apisign.io/mcp`; it is not installed or self-hosted from this repository. Clients connect using the Streamable HTTP transport and provide the API key in the `x-api-key` request header.

Templates use Markdown with Handlebars-style variables such as `{{client_name}}` and `{{effective_date}}`. When creating a contract, the agent supplies values for those variables. Signature placeholders use the same pattern: a single-signer document can use `{{signature}}`, while documents with multiple signers can assign separate signature fields through `signer_fields`.

A typical workflow is to find a template with `template_list`, inspect its variables with `template_get`, create a contract with its signers, and then call `contract_send`. The returned contract ID can be used with `contract_get` to check the contract and signer statuses.

## Setup and configuration

Create an API key in APISign under Account → API Keys. The key is displayed once. A Read Only key permits listing and reading templates and contracts; write tools are not included in the server's tool discovery response. A Read & Write key also permits changes and contract sending.

Add the hosted endpoint to an MCP client with a command such as:

```bash
npx add-mcp https://apisign.io/mcp --header '{"x-api-key": "your-api-key-here"}'
```

Manual configuration uses the following structure:

```json
{
  "mcpServers": {
    "apisign": {
      "url": "https://apisign.io/mcp",
      "headers": {
        "x-api-key": "your-api-key-here"
      }
    }
  }
}
```

The documented client locations include Claude Desktop configuration files, Cursor's MCP configuration, and ChatGPT's MCP server settings. Keep the API key private and choose the narrowest permission needed.

## Tools and capabilities

The APISign MCP server exposes twelve tools:

- `template_list` and `template_get` read organization templates.
- `template_create`, `template_update`, `template_upload`, and `template_archive` manage templates.
- `contract_list` and `contract_get` read contracts and signer status.
- `contract_create` creates a contract from a template or raw content.
- `contract_update` changes draft contract details or signers; it does not apply to completed or otherwise non-draft contracts.
- `contract_send` emails signers and bills the account for the document.
- `contract_cancel` cancels a draft or sent contract.

The repository also contains discovery metadata for the official MCP registry, Agent Plugins clients, and Glama. APISign publishes unauthenticated server-card endpoints for directory discovery.

_Full upstream README: https://allmcps.com/mcp/apisign/readme_