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, andget_blueprint_inputssays which. - "What is still unsigned this week?" —
find_workflowswith 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."
Public form links
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:
- Read the guide.
get_authoring_guidewith 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 exampledocs/core-concepts/blueprints, andexample/mutual_ndais a complete working project. - Look before writing.
list_resourcesandget_resourceshow 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_resourcewith dependencies returns the whole tree as YAML. - 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.
- 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 iskey@draft. Each document is sent whole, so a CSS or HTML asset carries its text incontent:and a schema carries its JSON Schema inschemaDefinition:. Thefile: ./pathform belongs to the CLI and is refused here. For a template on an existing PDF, the assistant first callsinspect_pdfon 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'swidgettakes. 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_pdfreturns 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. - Validate until it passes.
validate_resourceschecks 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. - Check the render as text.
check_renderruns 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 wordundefinedor 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. - Save drafts.
save_draftsvalidates 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. - Add sample data. For a new agreement,
save_scenariostores 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 withsave_scenarioinstead 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. - Preview the PDF.
preview_documentrenders 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 withget_previewinstead. 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 withinspect_pdfand the preview id: the fields as placed, their placement problems and, withimage_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. - Publish when you say so.
plan_publishshows 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_resourcesthen 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 withcreate_workflowat once; start in a test namespace. - Report what was built. Before calling the work done, the assistant reads each blueprint back with
get_resourcewith its dependencies, and its scenarios withlist_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
GETstream. SignStack serves Streamable HTTP only and answersGETwith 405. Choose Streamable HTTP (ortype: "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 pressrto re-authenticate; if no browser opens, start the CLI again from a folder whose.mcp.jsonlists 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.
