# SignRequest MCP > SignRequest lets you automate e-signatures and handle full document lifecycles via your AI client. It creates signing requests using templates, tracks signers in real time, and manages all associated documents—from initial creation to final webhook notification. You can manage users, teams, and custom webhooks directly from conversation. ## Overview - **Category:** productivity - **Price:** Free - **Tags:** digital-signature, contract-management, workflow-automation, document-tracking, legal-tech ## Description Look, you don't want to jump between tabs or copy UUIDs just to get a signature. This server connects your AI client directly into SignRequest, letting you run whole document workflows using plain language commands. It handles everything from building the initial paperwork to making sure your internal systems know the second someone signs off. **Managing Your Workspace and Users** Want to see what's going on? You can pull a list of every user account managed in your organization by calling `list_users`. Similarly, if you need an overview of organizational units, use `list_teams` to grab all the configured teams. To make sure everyone has the right access and structure, you can also run `list_templates`, which gives you a roster of every reusable document template you've saved in the system. **Building and Getting Documents** To start fresh, you can build a brand-new document using `create_document`. You just gotta feed it either an uploaded file URL or a specific template UUID, and tell it who needs to sign. If you need details on one of those saved templates before building, use `get_template` with its unique UUID. To get the full scoop on any existing paperwork, run `get_document`, feeding it the document's UUID for all the deep details. When a document is done and needs to be wiped, you can delete it permanently using `delete_document` and the UUID. If you just need a simple inventory of everything floating around your account, `list_documents` gives you that list right away. **Running the Signing Workflow** Got a document ready? You'll use `create_signrequest` to kick off the official signing process for an existing file. This starts tracking the entire thing until it’s done. To check up on where things stand, you can pull all info about one specific request using `get_signrequest`, which shows you who signed and how far along everyone is. If you need to verify a single document's status or details after sending out the request, use `get_document` again. **Automating Notifications (Webhooks)** Here's where the automation kicks in. You don't want to manually check for signatures; you wanna be notified instantly. To set that up, call `create_webhook`, giving it a URL so SignRequest can ping your systems when something happens—like someone signing or declining. Need to see what webhooks are already running? Use `list_webhooks` to pull the list of all registered endpoints and check their current status and destination URLs. If you're debugging, run `list_webhooks` to get that full picture. **The Bottom Line: What You Can Do** You can use `get_template` by UUID to grab template details; you'll also need it for the `create_document` call. To manage your setup completely, run `list_users`, `list_teams`, and then check out all available templates with `list_templates`. If you want a list of every document associated with your account, `list_documents` provides that overview. This collection lets you initiate the entire lifecycle: you build the paperwork (`create_document`), send it out (`create_signrequest`), track its status using UUIDs (`get_signrequest`, `get_document`), and connect it all to your other systems with webhooks. It's a complete loop, man. ## Tools ### create_document Creates a brand-new document in SignRequest when given a file URL or template UUID and required signers. ### create_signrequest Starts the official process of sending out a signing request for an existing document. ### create_webhook Registers and sets up a new webhook URL, allowing instant notifications when specific events happen in SignRequest. ### delete_document Permanently removes a document from your account using its UUID. ### get_document Retrieves the full details of a single, specific document by providing its unique UUID. ### get_signrequest Fetches all information about a specific signing request using its UUID, including signer status and progress. ### get_template Retrieves the details of an existing document template by providing its unique UUID. ### list_documents Returns a list of all documents associated with your SignRequest account. ### list_teams Retrieves a directory listing of the teams configured within your organization's SignRequest workspace. ### list_templates Lists all available, reusable document templates you have saved in the system. ### list_users Retrieves a list of every user account managed by your organization's SignRequest instance. ### list_webhooks Lists all webhooks you have registered, allowing you to see their current status and destination URLs. ## Prompt Examples **Prompt:** ``` List my recent SignRequest documents. ``` **Response:** ``` I've retrieved your documents. You have 3 recent documents: 'Service Agreement' (Status: Signed), 'NDA' (Status: Pending), and 'Offer Letter' (Status: Draft). Would you like details on any of these? ``` **Prompt:** ``` Create a new document using template UUID 550e8400-e29b-41d4-a716-446655440000 for signer test@example.com. ``` **Response:** ``` Document created successfully from the template. The document UUID is 771f9511-f30c-52e5-b827-557766551111. Should I proceed to send the signing request now? ``` **Prompt:** ``` Send document 771f9511-f30c-52e5-b827-557766551111 for signature with the message 'Please sign the agreement'. ``` **Response:** ``` The signing request has been sent for document 771f9511-f30c-52e5-b827-557766551111. I've included your custom message. You can track its status using the `get_signrequest` tool. ``` ## Capabilities ### Initiate Document Creation Builds a new document using either an uploaded file URL or a saved template UUID, assigning required signers. ### Start Signing Workflow Sends out a formal signing request for an existing document and tracks its status until completion. ### Retrieve Document Status Fetches specific documents or entire sign requests by their unique UUID to check progress or details. ### Automate External Triggers Creates and manages webhooks, ensuring your internal systems get real-time notifications for signing events (e.g., signature complete). ### Manage User Data Retrieves lists of organizational users, teams, and available templates to control access and document structure. ## Use Cases ### Onboarding a New Employee The HR admin needs to get three documents signed (NDA, offer letter, policy agreement). Instead of opening the template for each and manually adding signers, they ask their agent: 'Send the standard onboarding package for John Doe.' The agent uses `create_document` multiple times with templates and assigns all necessary roles. They then use `get_signrequest` to track progress until everything is complete. ### Automating Sales Pipeline Milestones A sales rep needs the signing status of a client's agreement to update their internal project board. Instead of checking the SignRequest portal, they ask: 'What's the latest on Acme Corp contract?' The agent runs `get_signrequest` and reports back the current status (e.g., 'Pending Legal Review'), allowing the rep to move the deal forward immediately. ### Compliance Cleanup The compliance officer needs to retire old, unused templates for regulatory reasons. They ask: 'List all templates that haven't been used in six months.' The agent runs `list_templates` and the officer can then use `delete_document` on specific UUIDs to clear out stale data. ### System Integration Hookup The development team needs their billing system to know when a contract is finalized. They ask the agent to 'Set up a webhook for signing completion.' The agent uses `create_webhook` and provides the necessary endpoint, linking document status directly into external business processes. ## Benefits - Track signers live. When you run `get_signrequest`, you don't guess status; you see exactly who has signed, who is pending, and when they need to act. - Build workflows without manual data entry. Use `create_document` with templates or URLs—the agent handles the setup for new contracts so you just give a prompt. - Get notified instantly. Setting up webhooks via `create_webhook` means your CRM updates automatically the second an agreement is signed, eliminating delays and status checks. - Manage permissions easily. The ability to run `list_users` or `list_teams` lets your agent verify if a user has the right access before trying to send them a sensitive contract. - Centralize governance. You can list every document (`list_documents`) or template (`list_templates`) in one place, giving you clear oversight of your entire digital filing system. ## How It Works The bottom line is you talk to your AI client, and it handles all the API calls required to manage signatures for you. 1. Subscribe to the SignRequest server and provide your API Key. 2. Your AI client authenticates with Vinkius using the key. The agent can then call specific tools like `list_users` or `get_template`. 3. You ask your agent a natural language query (e.g., 'Send this NDA to Jane Doe'). The agent formats and executes the necessary tool calls (`create_signrequest`) in sequence. ## Frequently Asked Questions **How do I start a signing request using create_signrequest?** You initiate it by providing the document's UUID or a template UUID. The agent handles the rest, setting up the formal workflow and notifying the signers immediately. **Can I list all my current contracts with list_documents?** Yes, `list_documents` pulls a full inventory of every document in your account. You can then ask for details on specific ones using their UUIDs. **What is the difference between get_document and get_signrequest?** `get_document` retrieves the file/metadata itself (the contract). `get_signrequest` tracks the *process* of signing—who signed it, when they signed it, and its current status. **How do I connect my external system to know when a document is signed?** You use `create_webhook`. This tool registers a URL on your side. When the signing event happens in SignRequest, it sends an instant notification payload to that URL. **How do I manage user access and verify team membership using list_users or list_teams?** You use `list_users` to pull a roster of all accounts associated with your SignRequest workspace. This tool lets you check who has access and helps confirm which teams are active before initiating any signing workflow. **What is the best way to find or validate existing document structures using list_templates?** `list_templates` pulls a full catalog of your reusable legal templates, giving you their UUIDs. You should run this first whenever you need to create a new contract because it verifies which pre-built structure you're working with. **If I no longer need a document and want to delete it completely, how do I use delete_document?** `delete_document` removes a file by its UUID from your account. Use this only when you are absolutely sure the document is outdated or sensitive data needs permanent removal. **When should I call create_document versus waiting until I run create_signrequest?** You use `create_document` to prepare and build a raw file first. You must successfully generate the document before you can pass it off using `create_signrequest` to actually start the signing process. **Can I check the current status and signers of a specific document?** Yes! Use the `get_document` tool with the document's UUID. The agent will return the document's status, signer details, and other metadata. **How do I see which reusable templates are available in my account?** Simply ask the agent to run the `list_templates` action. It will provide a list of all configured templates that you can use to create new documents. **Is it possible to automate notifications when a document is signed?** Yes, you can use the `create_webhook` tool to register a URL that will receive real-time notifications for events like `document_signed` or `signer_signed`.