# PandaDoc MCP

> PandaDoc connects your AI agent directly to your document workflow. Use natural conversation to manage contracts, create proposals, and track e-signatures without leaving your chat client. You get real-time status updates, can list all documents, generate new drafts from templates, and initiate signing sessions—all through simple commands.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** pandadoc, e-signature, document-automation, contracts-api, proposal-tracking, template-orchestration, workflow-automation, sales-closing, mcp

## Description

**PandaDoc connects your AI agent right into your document workflow.** You can manage contracts, build proposals, and track e-signatures just by talking to your chat client. You don't gotta leave the conversation window to run through your whole deal cycle; it's all here.

Your agent uses this server to talk directly to PandaDoc's engine. It lets you pull necessary data and handle signatures without clicking a single button in the web app. Here’s what you can do:

**Checking Status and Finding Files.** Need to know where a deal stands? You just run `list_documents` to search and get a list of every file, filtering by status or even searching for keywords in the names. If you want deeper info on one specific file, use `get_document_details`. That pulls all the metadata—like who viewed it or its current status—for that single document ID. You can also see what folders your documents are sitting in with `list_folders`.

**Building and Sending Documents.** Ready to start a new deal? Use `list_templates` first; that shows you every template UUID you've got lying around. Once you pick one, you run `get_template_details` to pull the structure information, so your agent knows exactly which fields need mapping. To make a draft, you call `create_document`, passing in a specific template UUID and the list of people who are receiving it. When that's ready, you use `send_document` to get the contract out there; that kicks off the signing process for one or multiple recipients.

**Managing Signatures.** Starting an e-signature session is simple: call `create_signing_session`. This sets up a live, embedded session where multiple people can sign the same document in real time. When everyone signs and it's finished, you use `get_download_link` to generate the direct link for the final, completed PDF. You don't wanna lose track of contacts? Run `list_contacts`; that fetches every contact stored in your PandaDoc account.

**Cleaning Up.** If you gotta scrap a document or it’s old news, you can use `delete_document` to remove that specific file ID from your account. It keeps everything clean and organized.

Basically, you tell your agent what you want—'Show me all proposals marked 'Sent'' or 'Draft a proposal using the Acme template for John Doe.' The server does it. You get real-time updates on status changes through natural conversation, skipping out on manual clicks entirely.

## Tools

### create_document
Creates a new PandaDoc document draft using a specified template UUID and list of recipients.

### create_signing_session
Starts an embedded session that allows multiple recipients to sign the same document in real time.

### delete_document
Removes a specified PandaDoc document from your account.

### get_document_details
Retrieves specific status and metadata for one existing document ID.

### get_download_link
Generates a direct, final download link for a completed or signed document.

### get_template_details
Pulls structural information and metadata for a specific template ID.

### list_contacts
Fetches a list of all contacts stored within your PandaDoc account.

### list_documents
Searches and lists all documents, supporting filters by status or general query text.

### list_folders
Shows the names and structure of document organization folders in your account.

### list_templates
Retrieves a list of every template UUID available for creating new documents.

### send_document
Sends an existing document to one or more recipients, triggering the signing process.

## Prompt Examples

**Prompt:** 
```
List all my PandaDoc documents and their statuses.
```

**Response:** 
```
I've retrieved your documents. You have 15 active files including 'Acme Contract' (Status: draft) and 'Renewal Proposal' (Status: sent). Would you like to check the recipient for any of them?
```

**Prompt:** 
```
Send the contract document doc_3847 to the client for electronic signature.
```

**Response:** 
```
Document doc_3847 "Service Agreement 2025" has been sent for signature. Recipients: John Martinez (CEO) at john@acmecorp.com and Lisa Park (Legal) at lisa@acmecorp.com. Both received email notifications with unique signing links. The document status has changed from Draft to Sent. Average completion time for similar documents is 2.3 days.
```

**Prompt:** 
```
List all available document templates I can use to create new proposals.
```

**Response:** 
```
You have 12 templates available. Top 5 by usage: "Standard SaaS Agreement" (used 34 times), "Consulting Proposal" (28 uses), "NDA Mutual" (22 uses), "Statement of Work" (18 uses), and "Sales Quote" (15 uses). 3 templates were updated in the last 30 days. All templates support dynamic field merging with recipient and company data.
```

## Capabilities

### Check Document Status
List all existing PandaDoc documents, filtering by status or searching by name.

### Generate New Proposals
Create a brand new document draft using a specific template and list of recipients.

### Send for Signature
Initiate an e-signature session for a specified document ID, including custom notification messages.

### Get Document Details
Retrieve specific metadata about one document, like who viewed it or its current status.

### Manage Templates
List all available templates in your library and retrieve their structure details for field mapping.

### Access Contacts & Folders
View the list of contacts or browse document organization folders within PandaDoc.

## Use Cases

### The Sales Closing Cycle
A rep needs to send a contract and track it. They ask the agent: 'Send the Master Service Agreement template (UUID 123) to Acme Corp.' The agent executes `send_document`. Later, they ask: 'What's the status of that document?' The agent runs `get_document_details` and reports back whether both signees have completed their part.

### Onboarding Documentation for HR
An HR manager has ten new hires starting. Instead of manually sending documents, they ask the agent to: 'Create a bundle of onboarding forms using the main template and send it to these 10 contacts.' The agent uses `create_document` with a recipient list, automating mass distribution.

### Auditing Old Agreements
An operations team needs an audit. They ask: 'List all documents that were sent last month and have not been signed.' The agent uses `list_documents` with status filtering, providing a clean list of files needing follow-up.

### Preparing for QBRs
A sales manager needs to summarize client engagement. They ask the agent to 'List all documents related to Client X.' The agent runs `list_documents`, giving the manager an immediate overview of every proposal and contract draft in one place.

## Benefits

- Check a contract's exact status using `get_document_details`. You instantly know if John signed it, or if the document is still in 'draft', without opening PandaDoc.
- You don't have to manually search for templates. Use `list_templates` and then pass the necessary UUID directly into `create_document`, accelerating proposal setup.
- Send a finalized document using `send_document`. It triggers the entire signing process, notifying multiple recipients at once while updating the status in real-time.
- Need to pull the final files? Use `get_download_link` after signatures are complete. This gives you a direct path to the signed PDF without any intermediate steps.
- Avoid context switching completely. Your AI client handles listing documents (`list_documents`), creating drafts, and sending—all from your preferred chat interface.

## How It Works

The bottom line is that your AI acts as a dedicated coordinator, running complex API sequences based on simple conversation.

1. Subscribe to this server and enter your PandaDoc API Key in the integration settings.
2. Your AI agent authenticates with PandaDoc, giving it access to read document lists and metadata.
3. You give a natural language command (e.g., 'Send the service agreement template to Jane Doe for signatures'). The agent executes the necessary tool calls.

## Frequently Asked Questions

**How do I list all my contracts and their current statuses using list_documents?**
Run `list_documents` with filters. You can specify the status (e.g., 'draft' or 'sent') or use a general query to filter by client name, giving you an immediate overview of every file.

**What is the difference between create_document and send_document?**
`create_document` just makes a draft copy in PandaDoc. It doesn't notify anyone or start any tracking. You must use `send_document` after creation to actually distribute it for signatures.

**Can I get the final, signed PDF with get_download_link?**
Yes, but only after the document status is confirmed as completed or signed. Running `get_download_link` on a draft will fail; you need to wait for signatures first.

**Do I need list_templates before creating a document?**
It's best practice. While the API might accept an ID, running `list_templates` lets your AI agent confirm the template UUID is active and valid for use in `create_document`.

**What do I need to know about setting up my account after getting my PandaDoc API Key before using `create_document`?**
You must pass your API credentials during the initial handshake. The server uses this key to authenticate all calls, ensuring you have permission to create documents and manage templates.

**If `get_document_details` returns a 'pending' status or errors out, what should I do?**
Wait a few minutes and try the call again. The details tool handles temporary sync issues by automatically retrying data retrieval until it captures the final document state.

**How can I use `list_contacts` to verify recipient information before I run `send_document`?**
You get a comprehensive list of all available users in your PandaDoc account. This confirms email addresses and roles, preventing errors when you send documents via the chat interface.

**Can I use `list_folders` to map out the document structure across my entire organization?**
Yes, this tool maps your whole organizational hierarchy. It lets you navigate and identify where specific contracts are stored without having to manually search through multiple locations.

**Can my AI automatically find the details for a specific document by its ID?**
Yes! Use the `get_document` tool with the Document ID. Your agent will respond with complete metadata, including signature status, expiration dates, and recipient info in seconds.

**How do I find my PandaDoc API Key?**
Log in to your PandaDoc account, navigate to **Settings** > **Integrations** > **API**, and click 'Generate API Key' to create your unique secret token.

**Can I generate a signing link for my app?**
Absolutely. Use the `create_session` tool to generate an embedded signing session for a specific document. The agent will return a unique URL for your recipient to sign immediately.