Connecting AI Assistants (MCP)

SignStack has a built-in Model Context Protocol server. Connect an AI assistant — Claude, Claude Code, ChatGPT, Gemini, or any other MCP client — to one of your namespaces, and it can build new agreements, look up blueprints, start agreements, follow their progress, send reminders and fetch signed documents, all through tools it calls on your behalf.

There is nothing to install or host. The MCP server is part of the SignStack API, and the assistant signs in through the same consent screen every connected app uses.

The server URL

In production the MCP server URL is https://mcp.signstack.ai/mcp. Studio shows the URL for the environment you are in, ready to copy, under Settings → Integrations → AI assistants. Each environment has its own: the test API and the production API are different servers with different URLs, so a connection made to one never sees the other.

Connect an assistant

Whichever client you use, the flow is the same: paste the server URL, the client sends you to SignStack to sign in, you pick the organization and namespace, review the permissions and click Allow access. The assistant is then connected to that one namespace.

Claude (web, desktop, mobile). Open Settings → Connectors, choose Add custom connector, and paste the server URL. No client id or secret is needed. Claude identifies itself to SignStack automatically.

Claude Code. In a terminal:

claude mcp add --transport http signstack https://mcp.signstack.ai/mcp

Then run /mcp inside Claude Code and choose Authenticate for signstack. Your browser opens the SignStack consent screen and returns to Claude Code when you allow access.

ChatGPT. With developer mode enabled, add a new connector with the server URL, then allow access on the consent screen.

Gemini. Open Connected apps, add one, and paste the server URL under Connect to an MCP server. Leave the client ID and secret empty: Gemini registers itself and opens the consent screen.

Other clients. Any client that supports remote MCP servers over Streamable HTTP with OAuth works. Clients that register themselves (through a Client ID Metadata Document or dynamic registration) need no setup on the SignStack side. If a client asks you for a client id, see Connecting apps with OAuth.

Who can connect

A namespace Editor or above. The server asks for twelve permissions: view, create and update workflows (void, send reminders); view, create and edit resources (blueprints, templates, schemas, assets and functions); view, create and edit scenarios (sample data); and view, create and edit shareable links (public forms). All of them are required, so every connection has the full tool set. A Viewer cannot connect: the consent screen shows the missing permissions and names the Editor role. No webhook or administrative permission is involved, so connecting an assistant never needs the Admin role.

One connection, one namespace. Like every connected app, an assistant is bound to exactly one namespace and its mode (test or live). Start with a test namespace. When the assistant is doing what you want, connect it to the live namespace as well; the assistant will ask which to use, or you tell it. Nothing from a test namespace ever reaches a live one.

Connections are listed in Studio under Settings → Integrations, where they can be disconnected at any time. Assistants that registered themselves are marked Unverified there and on the consent screen, meaning SignStack has not reviewed the client. That is normal for Claude, ChatGPT and other self-registering clients; only continue from the consent screen when you started the connection yourself.

What the assistant can do

Tool What it does Needs
get_connection Says which organization, namespace and mode the connection is bound to, who connected it and which permissions it holds —
list_blueprints Lists the published blueprints in the namespace View resources
get_blueprint_inputs Shows what a blueprint needs: each input's JSON Schema, which data properties feed each participant's name and email, and the documents it produces View resources
find_workflows Lists workflows, newest first, filtered by status, text or labels View workflows
get_workflow One workflow with its participants, their signing status, envelopes, documents and a Studio link View workflows
get_workflow_events One workflow's history, newest first: created, notified, viewed, signed, declined, voided, completed. Reminders are not recorded as events View workflows
create_workflow Creates a workflow from a published blueprint or a library listing and, in Run mode, starts signing Create workflows
void_workflow Voids an in-progress workflow with a reason Update workflows
send_reminder Re-sends a participant's signing email for one step Update workflows
get_signed_document_link A time-limited download link for a completed envelope's signed PDF View workflows
get_authoring_guide How to author agreements with these tools, the documentation pages, and a complete example project —
list_resources The namespace's blueprints, templates, schemas, assets or functions, drafts included View resources
get_resource One resource as YAML, optionally with everything it depends on View resources
inspect_pdf A PDF's layout: page sizes, text, blanks and form fields with boxes in field coordinates, for a PDF asset or a preview's document (with its fields and placement problems); one page as an image on request View resources
validate_resources Checks YAML documents together with the namespace resources they reference; writes nothing View resources
check_render Renders a blueprint envelope or a template as text with sample data, saved or not yet saved, and lists rendering defects; no PDF View resources, view scenarios
save_drafts Validates and saves documents as drafts, dependencies first Create and edit resources
list_scenarios The sample data linked to a blueprint or template View scenarios
save_scenario Checks sample data against a draft's inputs, saves it and links it to the draft Create and edit scenarios
preview_document Renders a saved blueprint envelope or template with sample data: watermarked PDF links View resources, view scenarios
get_preview The outcome of a preview that was still rendering View resources
plan_publish What a publish would do, writing nothing: each draft, the version it would get, what changed against its published version, and anything that would stop it View resources, view scenarios
publish_resources Publishes a draft and its draft dependencies as new versions; the assistant asks you first Edit resources, create scenarios
search_library Finds published agreements, or reusable templates, in the SignStack library that the connection may use View resources
get_listing One library listing: what its blueprint or template needs, its sample data and, for an agreement, the modes it supports View resources
copy_listing Copies a listing's blueprint or template, everything it depends on and its sample data into the namespace as drafts, keys optionally prefixed Create and edit resources, create scenarios
create_shareable_link Creates a public form link for a published blueprint or a listing and returns its URL Create shareable links
list_shareable_links The namespace's public form links with their state and submission counts View shareable links
update_shareable_link Turns a public form link off or on, or sets or clears its expiry or submission cap Edit shareable links

View resources is the permission the consent screen calls View blueprints, templates and schemas. A new connection lists all twenty-eight. If the person who connected it later loses the Editor role, the connection narrows to the read tools within the hour.

Some things an assistant is deliberately never able to do: obtain a participant's signing link (that link is the credential that lets someone sign), manage webhooks, delete anything, upload images or PDFs, use SignStack's own AI (the assistant writes everything with its own model), or start a workflow held for review — a reviewed workflow is started by a person in Studio.

Working with the assistant

A few prompts that work well once connected:

  • "Which blueprints can I start in SignStack, and what does the NDA one need?" — the assistant lists blueprints, then reads the NDA's inputs and participants.
  • "Start the NDA for Jane Doe at jane@example.com, company Acme Ltd, and label it crm_deal_id: 1234." — the assistant fills the blueprint's data from what you said, creates the workflow and gives you the Studio link. Participant names and emails come from the data: the blueprint's author decided which properties feed them, and get_blueprint_inputs says which.
  • "What is still unsigned this week?" — find_workflows with the in-progress status.
  • "Remind the second signer on the Acme NDA." — the assistant reads the workflow, finds the step, and sends the reminder.
  • "Get me the signed PDF for deal 1234." — the assistant finds the workflow by label and returns a download link. The link expires, so download promptly.

Creating a workflow renders its documents and emails the participants, exactly as if you had done it in Studio or through the API. The same validation, participant resolution and plan limits apply, and the assistant is told exactly what was wrong when a request is refused, so it can correct the data and retry. When a creation call times out, the assistant retries with the same idempotency key, so one workflow is created, not two.

Start from the library

Most agreements do not need to be written from scratch. The SignStack Library holds published, complete agreements with sample data, and the assistant reaches it with three tools: search_library finds listings whose title, description or key contains the search text; get_listing reads one, with the same input, participant and document detail get_blueprint_inputs gives for a namespace blueprint and the data of its sample scenarios, so the assistant can run it exactly as published; and from there the assistant either runs the listing as it is (create_workflow with the listing instead of a blueprint; the workflow belongs to your namespace, the documents come from the publisher's) or copies it with copy_listing.

A copy brings the listing's blueprint, every resource it depends on and its sample data into your namespace as drafts, in one call: keys are prefixed if you ask (acme_), references between the copied resources are rewritten, and any PDF or image the listing uses is copied into your organization. Nothing that already exists is touched: if a key is taken, the copy is refused before anything is written and the assistant chooses a prefix. From there the authoring loop below applies: check the render, edit, preview, publish.

The library also holds templates: a single document with its schemas and styles, to reuse inside your own blueprints. Ask for templates and search_library lists those instead of agreements. A template cannot be run or turned into a form link on its own: copy it, then reference it from a blueprint.

  • "Find a contractor agreement in the library and copy it as acme, then change the governing law to Delaware."
  • "Send the library NDA to jane@example.com in Review mode."

A shareable link is a public form: anyone who opens it fills in the inputs and a workflow starts, without the sender knowing the participants in advance. The assistant creates one with create_shareable_link for a published blueprint of the namespace or for a library listing, with a title and description it writes itself (SignStack proposes none), optional prefilled values that the form shows read-only (a prefilled list, or a checkbox prefilled as unchecked, stays editable), an expiry and a submission cap. It returns the URL for you to share. list_shareable_links shows the namespace's links with their state and counts. update_shareable_link turns a link off or back on, or sets or clears its expiry or submission cap; it changes nothing else. An expiry must be in the future. The assistant changes a link someone else created only after you agree. Deleting a link, or changing its title, prefill or source, is done in Studio.

  • "Give me a link where contractors can fill in the onboarding agreement; lock the company fields to Acme Ltd."

Authoring agreements

An assistant can also build agreements: write the schemas, document templates and blueprint for a new contract, check them, preview the PDF and publish. The assistant writes everything with its own AI model. SignStack checks, stores and renders what it writes and generates nothing itself, so authoring through an assistant uses no SignStack AI.

The assistant works in this loop:

  1. Read the guide. get_authoring_guide with no topic returns this loop, the rules that most often break a document, and the list of documentation pages. The assistant reads pages by topic as it needs them, for example docs/core-concepts/blueprints, and example/mutual_nda is a complete working project.
  2. Look before writing. list_resources and get_resource show what already exists in the namespace, so the assistant references existing schemas, assets and templates (key@version) instead of duplicating them. To change an existing agreement, get_resource with dependencies returns the whole tree as YAML.
  3. Plan before writing. The assistant works out and briefly states the data each blueprint input carries (what changes from one signing to the next, not the agreement's wording), the documents and which roles sign each, the participants and where each one's name and email come from, and the signing order. It asks you only about what changes the structure, picks sensible defaults for the rest and says what it picked. Building several agreements, it plans each one: each type of agreement gets its own document.
  4. Write YAML, leaf first: schemas, then CSS and HTML assets, then templates, then the blueprint. Every new or changed resource is version: draft, and every reference to it is key@draft. Each document is sent whole, so a CSS or HTML asset carries its text in content: and a schema carries its JSON Schema in schemaDefinition:. The file: ./path form belongs to the CLI and is refused here. For a template on an existing PDF, the assistant first calls inspect_pdf on the PDF asset: each page's size, its text, its blanks (runs of underscores, each with the label printed before it) and its own form fields, every one with a box in the coordinates a field's widget takes. It writes each widget from that layout (a blank or a form field as it is, or the space beside a label), never from a guess. If the PDF is not an asset yet, inspect_pdf returns a link to upload it in Studio: the assistant gives you the link and the namespace to upload into, then continues with the key you give it. It never asks for the file in the chat.
  5. Validate until it passes. validate_resources checks the documents together with the namespace resources they reference: the same check Studio and the AI chat run. Each finding names the resource, the path inside it and the problem. Validation judges structure only; it never runs the transform or the document template.
  6. Check the render as text. check_render runs the data transform and the document template with sample data exactly as the render pipeline does, and returns each document as text in about a second, with its fields, the stylesheets applied to it and a list of possible defects such as a leftover {{, the word undefined or a document with no styling — no PDF. It takes the unsaved documents, so the assistant checks before saving and after every edit, as often as it likes. A template backed by a static PDF returns each field's resolved value instead, and its placement problems: a field on a page the PDF does not have, off its page, overlapping another field, over printed text, or a value too long for its box. The assistant fixes every one.
  7. Save drafts. save_drafts validates again and saves the set as drafts, dependencies first. Nothing is saved unless all of it is valid, and saving the same set again changes nothing. Drafts are not used by any workflow until they are published.
  8. Add sample data. For a new agreement, save_scenario stores realistic data for every blueprint input, checked against the input schemas, and links it to the draft. A new draft of an agreement already published starts with copies of that version's scenarios, as in Studio: they are the draft's own, so the assistant updates them with save_scenario instead of adding new ones, and the published version's data stays as it was. Sample data comes before publishing: the scenarios follow the draft into the new version, and these tools cannot link one to a version already published.
  9. Preview the PDF. preview_document renders the real document: watermarked PDF links valid for an hour, the text of each document, and the same defect list. It is the only check for pagination, fonts, signature placement and the watermark, so it comes last, before publishing. A slow render returns a preview id to check with get_preview instead. A connection may start about ten previews a minute; the render check is not counted against that. For a template on a PDF, the assistant then looks at each page that has fields with inspect_pdf and the preview id: the fields as placed, their placement problems and, with image_page, the page as an image with each field's box outlined. An assistant that can see images looks at the pages of any document the same way, HTML ones included, for page breaks, a signature block split across two pages, and the styling.
  10. Publish when you say so. plan_publish shows first, without writing anything, which drafts would be published, the version each would get, what changed against its published version, the scenarios each blueprint takes with it and anything that would stop it. publish_resources then turns the draft, and every draft it depends on, into new versions, dependencies first. A published version cannot change, so the assistant asks you before publishing. The new version can be used with create_workflow at once; start in a test namespace.
  11. Report what was built. Before calling the work done, the assistant reads each blueprint back with get_resource with its dependencies, and its scenarios with list_scenarios, then tells you what it built, which scenario each blueprint uses, and what is published and what is still a draft.

Other people's work is safe. Scenario keys are shared across a namespace, and a person in Studio, the CLI or another app may have drafts of their own. The assistant never replaces a draft or a scenario that someone else created, and never publishes someone else's draft, unless you agree. The tool tells it who created what, and it either picks a new key or asks you.

Authoring through an assistant cannot upload images or PDFs: reference an existing asset, or upload the file in Studio or with the CLI. For a PDF or an image, a logo say, that is not uploaded yet, the assistant gets a Studio link to hand you, from inspect_pdf or get_resource. It cannot delete resources or scenarios. It cannot generate sample data or descriptions with SignStack's AI, so the assistant writes those itself.

Connections made before authoring was available hold only the four original permissions, so they can read resources and the library but lack every tool that saves, publishes, copies, uses sample data or works with form links; connections made before shareable links were offered hold nine and lack the link tools; connections made before link editing hold eleven and lack update_shareable_link. Disconnect and connect again to grant the new ones.

Disconnecting

In Studio, open Settings → Integrations and click Disconnect on the connection. The assistant's access stops within seconds. Removing SignStack in the assistant's own settings may not end the connection on the SignStack side, so disconnect in Studio to be sure.

Troubleshooting

  • "SSE error: Non-200 status code (405)" or "(401)" when connecting. The client is set to the old SSE transport, which opens a GET stream. SignStack serves Streamable HTTP only and answers GET with 405. Choose Streamable HTTP (or type: "http", --transport http, depending on the client) and reconnect; an existing connection stays valid.
  • The assistant says it is not authorised, or asks to reconnect. The connection was disconnected, or the user who connected it lost access to the namespace. Connect again.
  • "Allow access" is disabled on the consent screen. You need the Editor role in the namespace you chose. Pick a namespace where you are an Editor, or ask a namespace Admin.
  • A tool is missing. The connection no longer holds that permission, usually because the person who connected it is no longer an Editor. Restore the role, or have an Editor connect. A connection made before authoring was available lacks the authoring permissions, one made before shareable links were offered lacks the link tools, and one made before link editing lacks update_shareable_link: disconnect and connect again.
  • GitHub Copilot CLI stops connecting after an hour. Access tokens live an hour and the CLI does not renew them on its own. In the Copilot session run /mcp show, select the SignStack server and press r to re-authenticate; if no browser opens, start the CLI again from a folder whose .mcp.json lists the server.
  • The assistant says a key is already in use. A draft or scenario with that key belongs to someone else, such as a person in Studio, the CLI, another app or another published agreement. Let it choose a new key, or tell it to replace the existing one if you are sure. A library copy never replaces anything: ask for a prefix instead.
  • "Rate limit exceeded". A connection may make about sixty requests a minute, and each call in a batch counts as one. The assistant is told how long to wait.
  • "The signed document is still being prepared". The envelope completed seconds ago and the PDF is not stored yet. Ask again shortly.
  • "The signed PDF exists once every participant has signed". The workflow is still in progress; the assistant names who has not signed. Asking again does not help until they do.
  • The consent screen says the app is unverified. Expected for self-registering clients such as Claude and Gemini. Continue only if you started the connection yourself.