OneSpan Sign MCP for AI. Run complex e-signature workflows via conversation.
Works with every AI agent you already use
…and any MCP-compatible client








How this MCP server connects to your AI agent
OneSpan Sign automates entire e-signature workflows directly through your AI agent. Instead of logging into a separate portal for every contract, you can manage document packages, upload metadata, and track signing progress using natural conversation.
It handles everything from creating new deal packages to downloading final signed documents in one command.
What AI agents can do with OneSpan Automation
Configure callback
Sets up or receives event notifications so your agent is alerted when a package finishes or a signer takes action.
Create package
Starts the process by generating a brand new digital transaction package ready for documents and signers.
Download documents zip
Retrieves all signed documents from an entire completed package, delivering them as one ZIP file.
Creates new digital transaction packages to organize related documents and assign signers for a specific deal.
Uploads physical or draft documents into existing packages, adding necessary details like titles and content configurations.
Updates a package's status (like setting it to SENT) which automatically notifies participants to take action.
Configures real-time callbacks so your agent knows exactly when packages are completed or signers interact with the documents.
Downloads all finalized, signed documents from a package into one single ZIP file for easy archiving and record-keeping.
Ask an AI about this
Waiting for input…
What AI agents can do with OneSpan Sign with 5 Tools
These tools let your agent handle the entire process of creating contract packages, uploading files, controlling workflow statuses, and retrieving final signed documents.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using OneSpan on VinkiusConfigure Callback
Sets up or receives event notifications so your agent is alerted when a package finishes or a signer takes action.
Create Package
Starts the process by generating a brand new digital transaction package ready for...
Download Documents Zip
Retrieves all signed documents from an entire completed package, delivering them as...
Update Package
Changes the status of a contract package (for instance, moving it to 'SENT') to...
Upload Document
Attaches documents to an existing package and adds specific metadata about that file.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with OneSpan, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by OneSpan. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Built on the Model Context Protocol (MCP) for Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 5 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Dealing with contract paperwork means jumping between five different web tabs., Solved with Vinkius AI Gateway
Today's process involves logging into the initial document portal to create a package. Then, you switch over to a metadata management system to upload details. After that, you go back and manually click buttons to change the status from 'READY' to 'SENT.' Finally, once everyone is done signing, you download every single file individually and then zip them up yourself.
With this MCP, those manual handoffs vanish. You simply ask your agent to start a package using `create_package`. Uploading documents and metadata happens in the same conversation, and when signatures are needed, one command—`update_package`—kicks off the entire process. You get everything you need, including all final signed copies, through simple commands.
OneSpan Sign MCP gives you full control over your document lifecycle.
You eliminate the tedious steps of manual status updates and file aggregation. There's no need to copy package IDs from one screen, paste them into another system, or track down a dozen separate completion emails just to get an archive.
The difference is control. You dictate the entire flow—from initial document upload with `upload_document` to final archival via `download_documents_zip`—all within your agent's natural conversation.
What your AI can actually do with this
Need to handle contracts? This MCP connects your OneSpan Sign account directly to your AI agent so you don't have to navigate multiple websites or click through complicated dashboards. You manage the entire digital signing lifecycle using plain conversation.
For example, if a deal is ready to go, you tell your agent to start a new transaction package. The system creates it and registers it. Next, you upload all necessary documents and attach specific metadata. When everyone's signature is needed, you simply update the package status, kicking off the signing process for participants automatically.
When everything’s done, you get one command that downloads every signed document into a ZIP file. It makes managing legal paperwork feel like talking to a teammate, not operating complex software. You access this power through Vinkius, connecting it instantly to your preferred AI client.
019ea5fb-e105-7292-8743-994c20e1facd Here's how it actually works
The bottom line is that you manage complex digital signing processes using simple natural language commands within your existing AI workflow.
First, subscribe to this MCP and enter your OneSpan API Key (and Base URL if needed).
Next, use your AI client to issue commands like 'create a new contract package' or 'upload the NDA document'.
Finally, when the process is complete, ask your agent to download all signed files into a single archive.
Who is this actually for?
This MCP helps professionals who handle high volumes of contracts and agreements. It's for anyone tired of manually logging into multiple document portals, tracking status updates via email chains, or having to stitch together final signed documents from different sources.
Quickly initiating signing processes and verifying the current legal status of client agreements without leaving their primary workspace.
Automating the creation of contract packages for new clients and getting real-time visibility into where every signature stands in the sales cycle.
Managing employee onboarding documentation, agreements, and policy acknowledgments efficiently by issuing commands to start and track document flows.
What Changes When You Connect
Start deals faster. Instead of manually setting up a contract in a web portal, use the create_package tool to initiate a signed deal package with just a few commands.
Keep your records clean. Use upload_document to attach documents and add metadata directly to the package before anyone signs anything.
Get real-time status updates. Set up event notifications using configure_callback so your agent alerts you immediately when signatures are finalized or stalled.
Manage the flow easily. Need to prompt signers? The update_package tool moves the contract status, which automatically triggers the signing notification for all participants.
Archive effortlessly. Instead of downloading 10 separate PDFs, use download_documents_zip to get every final signed document instantly packed into one ZIP file.
See it in action
Closing a Vendor Agreement
A legal team needs to finalize a vendor contract. They ask their agent: 'Create a new OneSpan transaction package for the Acme contract.' The agent responds with the Package ID, and the user immediately runs upload_document to attach all necessary NDAs before finally running update_package to send it out.
Onboarding a New Employee
An HR specialist needs to process five documents (W4, handbook, contract). They tell their agent to first run create_package, then systematically use upload_document for all files. Once complete, they ask the agent to set up notifications using configure_callback so they know when the employee signs everything.
Following Up on Stalled Contracts
A sales rep finds a package hasn't moved in days. They instruct their agent to check the status and, if necessary, run update_package to nudge the signers again. When it finally moves forward, they can immediately use download_documents_zip for final record-keeping.
Completing a Due Diligence Audit
An auditor needs all signed contracts from a specific deal. They ask their agent to gather the data using one command, triggering download_documents_zip. This avoids having to download and manually merge dozens of individual PDFs.
The honest tradeoffs
Only uploading files randomly
Just dropping a folder of signed contracts into the agent without context. The AI can't know if they are ready to be archived or just drafts.
Always start by running create_package to give the documents structure, then use upload_document with proper metadata before trying to download them using download_documents_zip.
Treating it like a simple file share
Assuming that just uploading a PDF means the contract is signed and ready for archiving. It's not; the status needs to change first.
After upload_document, you must use update_package to move the package state (e.g., to SENT) before any signatures are finalized and can be pulled via download_documents_zip.
Ignoring follow-up needs
Running a process and then leaving it, meaning you won't know if the signers opened or ignored the contract.
Always set up configure_callback early in the workflow. This ensures your agent gets real-time alerts on signer activity, giving you visibility into potential bottlenecks.
When It Fits, When It Doesn't
Use this MCP if your primary pain point is managing complex document lifecycles—the flow from draft to final signature and archiving. You need the system to remember metadata, manage status transitions (like going from 'DRAFT' to 'SENT'), and handle multiple participants simultaneously. If you only ever process simple data forms or need to send one isolated PDF without tracking signatures, this is overkill; a basic file transfer tool would suffice. But if your job requires coordinating dozens of legal agreements across different departments and needing guaranteed audit trails, this MCP is mandatory.
Questions you might have
How do I use OneSpan Sign MCP to start a contract? +
You start by telling your agent to run the create_package tool. This initializes the digital package, giving you a unique ID that you must reference for all subsequent actions.
Can I upload documents without creating a package first? +
No. You must use create_package to establish the container before you can attach files. After creation, you run upload_document to add your materials.
What is the best way to get all final signed documents? +
After the signing process is complete, use the download_documents_zip tool. This gathers every single signed document from the package and compresses them into one ZIP file.
Does OneSpan Sign MCP handle status changes? +
Yes, you control the workflow using update_package. Changing the status—for example, to SENT—is how you formally tell all participants it's time to sign.
How do I know if my agent is tracking signing activity? +
You configure real-time updates using configure_callback. This tells the system to alert your agent when key events, like package completion, occur.
We've already built the connector for OneSpan Sign. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 5 tools are live and waiting.
You're up and running in seconds.
Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.