accordsign-mcp 1.2.1

accordsign-mcp

A local MCP server that connects an AI agent — Claude Desktop, Claude Code, Cursor, or any MCP client that can start a local server — to your Accordsign account.

It cannot send anything. There is no send, void, remind or field-placement tool, and the only thing it can remove is a draft it made itself. The agent can read your envelopes, count them, save completed documents to your computer, list templates, create a draft — from text or from a PDF or Word file on your computer — that a person then opens in Accordsign, places signature fields on, and sends, and discard such a draft when you ask. That is the whole surface, and it is deliberate.

It runs on your machine, talks to Accordsign over HTTPS with your own API key, and has no privileged access of any kind — it uses the same public API any integrator would.

---

Before you install

• The .NET 8 SDK. accordsign-mcp is a .NET tool that targets .NET 8. Install the SDK from dot.net first; the tool will not start on a machine that only has a newer .NET.
• An Accordsign API key, on a Growth or Enterprise plan. In Accordsign, open Account → API keys and create one. It is shown once and stored only as a hash, so copy it when it appears — if you lose it, revoke it and make another.

On any other plan the tools answer "This Accordsign account's plan does not include API access."

---

Install

dotnet tool install -g accordsign-mcp

Update later with dotnet tool update -g accordsign-mcp.

The tool is installed here:

System	Path
macOS, Linux	~/.dotnet/tools/accordsign-mcp
Windows	%USERPROFILE%\.dotnet\tools\accordsign-mcp.exe

Use that full path in your client's configuration. MCP clients start the server themselves, without your terminal's PATH, and ~/.dotnet/tools is not on the default PATH everywhere in any case — a bare accordsign-mcp usually fails with executable not found. Write the path out with your own user name: most clients do not expand ~.

---

Configure your client

Two environment variables:

Variable	Required	What it is
ACCORDSIGN_API_KEY	yes	Your as_live_… key
ACCORDSIGN_API_BASE	no	Defaults to https://api.accordsign.app/v1. Point it at staging to test

Claude Desktop

Open Settings → Developer → Edit Config and add this to claude_desktop_config.json:

{
  "mcpServers": {
    "accordsign": {
      "command": "/Users/you/.dotnet/tools/accordsign-mcp",
      "env": {
        "ACCORDSIGN_API_KEY": "as_live_your_key_here"
      }
    }
  }
}

On Windows, command is the .exe path with each backslash doubled, for example "C:\\Users\\you\\.dotnet\\tools\\accordsign-mcp.exe".

Then quit Claude Desktop completely — from the menu, or ⌘Q on a Mac; closing the window is not enough — and open it again. The server is listed under Settings → Developer, not under Connectors, with seven tools.

Claude Code

claude mcp add accordsign --env ACCORDSIGN_API_KEY=as_live_your_key_here -- /Users/you/.dotnet/tools/accordsign-mcp

Cursor

Add the same mcpServers entry as for Claude Desktop to .cursor/mcp.json, or through Settings → MCP → Add new server.

---

The seven tools

Tool	What it does	What it does not do
list_envelopes	Lists envelopes, newest first, filterable by status	Cannot send, void, remind or change anything
summary_envelopes	Counts the account's envelopes by status, in one call	Takes no filters — it always covers the whole account
get_envelope	One envelope in full: status, per-recipient state, timestamps	Read-only
get_document	Saves the signed PDF of a completed envelope to your computer	Refuses drafts and in-progress envelopes; never returns the PDF inline
list_templates	Your reusable templates and their roles	Cannot create, edit or send from one
create_draft	Creates a draft from text, or from a PDF or Word file	Sends nothing, places no fields, uses no document allowance
discard_draft	Discards a draft that create_draft made	Cannot touch any other envelope, a sent draft, or void or send anything

create_draft

Give it the recipients (each with a name, an email and the role signer or cc, 1 to 20 of them) and the document in exactly one of these ways:

• file_path — the absolute path of a file on your computer. The agent is told to prefer this whenever you have the document as a file. The file must be:

  • a PDF (.pdf) or a Word document (.docx), and actually be what its name says;
  • at most 20 MB (20,971,520 bytes);
  • not encrypted or password-protected — Accordsign cannot place fields on an encrypted PDF.

  Each of these is checked on your computer before anything is sent. The title defaults to the file name without its extension. Only the file's name and contents are sent, never the folder it is in. A file of up to 2 MB travels inside the draft request; a larger one is uploaded first (see Large files below).

• text — the document body, as markdown (the default) or plain text. A title is required.

• document_id — to continue an earlier call that uploaded a large file and said it was still being prepared. The agent repeats that call, keeping file_path, and adds document_id, so the file is not uploaded a second time. On its own, document_id is only for a document uploaded to Accordsign some other way (POST /v1/documents).

An optional message is shown to the recipients.

A retry returns the same draft. The request carries an idempotency key derived from what the draft is — the title, message, recipients in order, and the text or the file's name and contents (whether the file travelled inline or was uploaded). Asking again for the same document, to the same people, with the same words returns the draft that already exists. Change anything and you get a new draft.

One request is one key. A call that names file_path keeps the file's key when it is continued with document_id. So a repeat after a lost answer, or a continuation of one, returns the draft that already exists instead of making a second. A call with document_id alone has its own key, made from the upload's id. For a document this tool uploaded from a file, the tool refuses that call and says which call to make instead. It remembers those uploads — each with the contents it sent — only while it is running, which is also what lets it refuse a continuation whose file has changed since (Large files).

The preparing status

A draft answers with one of two statuses:

• draft — ready. Open it in Accordsign, place the fields, send.
• preparing — the envelope exists and its document is still being set up. Call get_envelope again after a few seconds.

preparing is not a failure. The draft was created and its envelope_id is real. The tool description tells the agent this in as many words, because an unfamiliar status is exactly the kind of thing a model reports as an error when it isn't one.

get_envelope then answers preparing: true while the draft is still being set up and preparing: false once it opens. In the rare case that it cannot be set up at all, it answers preparation_failed: true. That one is terminal, so the agent stops checking. Nothing was sent and no document allowance was used.

Large files

A file over 2 MB is uploaded first (POST /v1/documents, up to 20 MB), and the draft is created once Accordsign has prepared it. The upload is given up to 5 minutes; the tool then checks the document every 5 seconds for up to about 40 seconds.

If the document is not ready by then, the tool first asks Accordsign, under this request's key, whether an earlier call with the same arguments already made the draft (that call's answer may have been lost). If one did, that draft comes back, with a note that nothing new was created. Otherwise no draft exists yet, and that is expected: a long document can take a minute or more. The tool's answer carries the uploaded document's id. It tells the agent to wait about 15 seconds and call create_draft again with the same arguments, keeping file_path, and to add document_id set to that id. That continues from the upload rather than sending the file again. After three tries the agent stops and tells you.

The checks count towards your key's per-minute rate limit like any call. When only one request is left in the current minute, the tool waits for the limit to reset rather than spend the request the draft itself needs — or, if that would take too long, hands the agent the document id to continue with.

An uploaded document is single-use: once a draft is made from it, it cannot be used for another. An upload that is never used is deleted after 7 days.

The file must still be the file that was uploaded. A document id names an upload, not a version of your document, so the tool records what it sent and checks it again when the call is continued. If the file at that path has changed in between, the continuation is refused — that upload holds the earlier contents, and drafting it would attach the wrong document to this request. Repeat the call with file_path alone to send the file as it is now, or put the earlier file back. If the tool has been restarted since the upload it cannot know what that document holds, so it sends the file it can see rather than trusting the id, and says so in its answer; the call still carries the file's key, so a draft an earlier call made comes back instead of a second one being created.

Files over 2 MB need an Accordsign environment running Public API 1.10.0 or later.

Retrying

A file of up to 2 MB, or text, can also take longer to prepare than one call allows. The tool then says Accordsign is still preparing the document — that is expected, not a fault, and no draft exists yet. The agent waits about 15 seconds and repeats the call with exactly the same arguments, which continues where the first call left off. After three tries it stops and tells you.

Because the retry key is derived from the request, an identical repeat is sometimes refused on purpose — when an earlier call for the same arguments failed, or left nothing on record. The tool's message then tells the agent to repeat the call with attempt set one higher (2, then 3), which makes a fresh request; for an unrecorded earlier call it checks list_envelopes first, in case a draft was created anyway. Leave attempt unset otherwise: unset and 1 are the same request.

If Accordsign cannot read the file at all — damaged, or protected in a way the local checks could not see — the agent is told not to retry it and to ask you for a copy that opens normally.

Drafts from templates are not available yet, and a daily limit applies per key (30 drafts in 24 hours by default).

discard_draft

Removes a draft that create_draft made — the draft and its document are deleted in Accordsign. Give it the draft's envelope_id. The agent is told to use it only when you ask.

• Only drafts made through this connector can be discarded. Anything else — a draft you started in the Accordsign app, an envelope sent some other way, another account's — is answered as not found.
• A draft that has since been sent is not discarded; it can be voided in Accordsign.
• Discarding the same draft twice is harmless.
• A file uploaded for that draft stays used; drafting it again uploads it again.
• If the agent later repeats the create_draft call that made a discarded draft, it is told so and that a fresh request needs attempt set one higher.

get_document

Saves the signed PDF of a completed envelope and returns where it went:

{
  "path": "/Users/you/Documents/ENV-6F1C9A52.pdf",
  "size_bytes": 53258,
  "sha256": "…",
  "content_type": "application/pdf",
  "message": "Saved the signed PDF (53,258 bytes) to /Users/you/Documents/ENV-6F1C9A52.pdf."
}

• save_to (required) — an absolute path. If it is an existing folder, the PDF is saved inside it as ENV-XXXXXXXX.pdf, the reference shown on the signing page. Otherwise it is the file to write, and its folder must already exist.
• overwrite — false by default. An existing file is never replaced unless this is true, and the download is skipped when the file would not be written.

A document that has only just completed can still be on its way to storage; the tool then says it is still being prepared, and a retry a few seconds later succeeds. The SHA-256 is computed from the file as written, so you can check the copy on disk against it.

---

Try it

Once configured, ask your agent things like:

What Accordsign envelopes are waiting on signatures?

How many envelopes do I have in each status?

Save the signed contract from envelope … to my Documents folder and summarise its termination clause.

Put /Users/you/Documents/Northwind NDA.pdf into Accordsign as a draft, with Asha Rao (asha@example.com) as the signer.

Draft the 60-page supply agreement in /Users/you/Documents/Supply agreement.pdf for Kiran Mehta (kiran@example.com) to sign. — a file over 2 MB, uploaded first.

Draft a one-page mutual NDA between Seed Data Systems and Northwind, with Asha Rao (asha@example.com) as the signer, and put it in Accordsign as a draft.

The last three create drafts. Nothing is sent — open Accordsign, place the signature fields where you want them, and send it yourself.

---

Testing against staging

Point ACCORDSIGN_API_BASE at the staging API and use a key minted on that environment:

{
  "mcpServers": {
    "accordsign-staging": {
      "command": "/Users/you/.dotnet/tools/accordsign-mcp",
      "env": {
        "ACCORDSIGN_API_KEY": "as_live_your_staging_key",
        "ACCORDSIGN_API_BASE": "https://dev01api.seeddata.app/v1"
      }
    }
  }
}

Keys are per-environment: a staging key will not work against production, and vice versa. Running both entries side by side is the intended way to try changes before they reach live documents.

A walkthrough worth doing once, end to end:

1. Ask the agent to list envelopes — confirms the key and the base URL.
2. Ask it to create a draft with one signer, once from text and once from a PDF.
3. Open each draft in Accordsign. The recipients should be populated and there should be no signature fields — you place those.
4. Check the envelope is still Draft, nothing was emailed, and your document allowance is unchanged.

Step 4 is the one to actually check. It is the whole promise of this tool.

---

Troubleshooting

The server does not appear, or the client says the executable was not found. Use the full path from the Install section as the command, with your own user name in it.

"ACCORDSIGN_API_KEY is not set." The variable did not reach the server. Put it inside the env block of the accordsign entry, not in your shell profile — the client starts the process itself and does not inherit your terminal's environment.

"Accordsign rejected the API key." The key is wrong, revoked, or from the other environment.

"This Accordsign account's plan does not include API access." API keys need a Growth or Enterprise plan.

The server exits straight away, or mentions a missing .NET runtime. Install the .NET 8 SDK (see Before you install). Then run the full path in a terminal: it should sit waiting for input, which is correct, and any startup error prints there.

"… must be a full absolute path." file_path and save_to are not resolved against any folder, and a leading ~ is not expanded. Give the whole path.

A large file keeps coming back as "still being prepared". A long or image-heavy document can take a few minutes. The agent should be repeating the call with file_path and document_id; after three tries it stops, and asking again a little later continues from the same upload for up to 7 days.

"… may not accept uploaded documents for drafts yet." Files over 2 MB need Public API 1.10.0 or later on the environment ACCORDSIGN_API_BASE points at. Use a file of at most 2 MB there, or send the document from the Accordsign app.

---

What changed in 1.2.0

1.2.0 is the first release after 1.0.x (there was no 1.1.0 release); everything below is new since 1.0.x.

• create_draft accepts file_path: a PDF or Word file, checked on your computer first. title is optional when a file is given. Files up to 2 MB travel inside the request; files up to 20 MB are uploaded first and drafted once Accordsign has prepared them.
• create_draft accepts document_id. With file_path, it continues a call that uploaded a large file and ran out of waiting, without uploading the file again, under the same key. Alone, it drafts a document uploaded some other way. Give text or file_path, not both.
• create_draft accepts attempt, and its refusal messages now say what to do next: repeat the same call after a timeout, add document_id to it after an upload, or raise attempt when an earlier identical call cannot be repeated.
• Uploads get their own, longer time limit (5 minutes); checking an upload respects your rate limit.
• discard_draft, the seventh tool: removes a draft create_draft made, and nothing else.
• get_document saves the PDF to disk and requires save_to. It no longer returns the document as base64 — the result is the saved path, size and SHA-256. An existing file is not replaced unless overwrite is true.
• get_document now explains an envelope that is not complete, a download that was interrupted, and an unreachable Accordsign in plain sentences.
• Messages point to Account → API keys, where keys are actually created.

Privacy

Documents you ask the agent to read are sent to your AI provider under their terms — that is what asking an agent to read a document means. This tool holds nothing: no cache, no copy, no telemetry. It passes requests to Accordsign with your key and passes answers back; a signed PDF is written only to the path you or your agent chose, and a file you draft from is sent by name and contents, never by where it sits on your computer.