add-document-recipient
ChatGPTUse this tool to add a new recipient to a document. Requirements: - At least one of email or phone must be provided.
Productivity
Overview
PandaDoc lets you create, send, and track documents for signature directly from your Claude conversation. Ask Claude to prepare an NDA from your existing templates, send a proposal to a client, check which contracts are still waiting to be signed, or pull the complete audit trail for any document. Connect your PandaDoc account to manage your entire document workflow without leaving the conversation.
Tools
assign-document-recipient-fields
ChatGPTUse this tool to assign, reassign, or remove document field assignments. Each entry maps a list of field external IDs to a recipient. Provide recipient_id to assign or change the recipient for the given fields. Omit recipient_id to remove the assignment so those fields become unassigned. In case it is unclear which recipient should be assigned to a field, ask clarifying questions based on fields present in the document. After fields are assigned to a recipient, that recipient becomes a signer and will be able to sign on the assigned fields in the document.
catalog_categories_search
ChatGPTSearch the workspace's product catalog categories by free text against the category name. Use this to find an existing category before assigning it to a catalog item, or before renaming, moving, or deleting it by UUID. A query with no matches returns an empty list — treat that as "nothing found," not an invitation to guess a category or invent one. This tool only matches by name — it does not browse the full hierarchy or show parent/child relationships.
catalog_category_create
ChatGPTCreate a new category in the workspace's product catalog. This is a write operation. Before calling this tool, show the user the category name and where it will be created, then explicitly ask them to confirm. Do not call it from an earlier request that only searched for or discussed categories. Omit
parent to create a top-level category. To create a nested category, pass the UUID of its immediate parent; resolve the category first and never guess its UUID. The service enforces the workspace category-count and nesting-depth limits. If either limit is reached, this tool fails with a human-readable error and creates nothing. Report that error to the user instead of retrying with a different parent or name.catalog_category_delete
ChatGPTPermanently delete a category and all of its descendant categories from the workspace's product catalog. This is a hard delete with no soft-delete state and no restore. Before calling this tool, identify the exact category by name and UUID, explain which deletion mode will be used and its consequences, and explicitly ask the user to confirm deleting that specific category. Never guess a category UUID or treat an earlier request to find, view, or modify a category as deletion approval. Leave
all_items false to preserve the catalog items in the deleted category subtree. The category and all descendant categories are permanently deleted, while their items are moved to the deleted category's parent. If the deleted category is top-level, those items become uncategorized. Set all_items to true only when the user explicitly confirms that the items should also be permanently deleted. In this mode, the category, all descendant categories, and every catalog item in that subtree are deleted with no restore. Never infer this mode or silently retry with a different mode.catalog_category_get
ChatGPTGet a specific catalog category by UUID — use once a category has been identified (for example via
catalog_categories_search) and its parent is needed. parent is the immediate parent category's UUID, or null for a top-level category — parent_name is its human-readable name, use that when referring to the parent in a response to the user. For the full ancestry or the category's children, use catalog_category_tree instead.catalog_category_tree
ChatGPTGet the workspace's catalog category hierarchy as a nested tree. Omit
category_uuid for the complete tree of every top-level category and its descendants — use this to browse the full hierarchy or see a category's children. Provide category_uuid (for example from a catalog_categories_search or catalog_category_get result) to instead get the path from the catalog's top level down to that category: the branch containing it (with its sibling categories at each level along the way, and the requested category itself as the deepest node — without its own children), plus every other top-level category as a separate, childless placeholder node. This does NOT return the requested category's children — to see those, omit category_uuid and find the category by name in the full tree instead. For finding a category by name, use catalog_categories_search instead; for a single category's immediate parent, use catalog_category_get.catalog_category_update
ChatGPTRename and/or move an existing category in the workspace's product catalog. Before calling this tool, identify the exact category by UUID, resolve the target parent when moving it, show the user the before and after state, and explicitly ask them to confirm that specific update. Set
name to rename the category. Omit parent_category_id to leave its parent unchanged, set it to a category UUID to move beneath that category, or set it to null to move the category to the top level. At least one of name or parent_category_id must be supplied. When both fields are supplied, the move runs first and the rename second. They are separate operations, not one transaction. If the move fails, the rename is not attempted. If the move succeeds but the rename fails, the category remains moved; report that partial result and fetch the category again instead of claiming the whole update was rolled back.catalog_item_create
ChatGPTCreate a new item in the workspace's product catalog. This is a write operation — always call
catalog_items_search first to check for an existing item with a similar name or SKU, and warn about close matches instead of silently creating what may be a duplicate. Before calling this, show the user exactly what will be created (title, price, SKU, and bundle contents if any) and explicitly ask them to confirm. Do not call this from an earlier request to search, price, or discuss an item alone — only after the user has explicitly agreed to create it in this exchange. For flat pricing, set price_configuration.price and leave pricing_model as "fixed". For quantity-tiered pricing, set pricing_model to "volume_based" and provide tiers instead — never invent a flat price for a volume-priced item. Set billing_type to "recurring" only when the item is charged on a repeating cycle, and always pair it with billing_cycle. Set type to "bundle" to create a bundle instead of a regular item. bundle_items is required when type is "bundle" (up to 300 lines) and must be omitted otherwise. Each line is either a reference to an existing regular catalog item (kind: "catalog_item", with its uuid — resolve this via catalog_items_search/catalog_item_get first; this fails with a clear error if the uuid doesn't resolve to an existing regular item) or a one-off custom line not backed by any catalog item (kind: "custom", with its own title/price/currency). The bundle's own price_configuration is always a flat price or tiers you set directly, exactly like a regular item — it is never derived automatically from the bundle's contents, regardless of what those contents cost or how they're billed. This tool's response never includes bundle composition, even for a bundle — call catalog_item_get on the returned uuid afterward if you need to confirm what was actually created. If the workspace's plan doesn't include Product Catalog, or the caller's role can't edit the catalog, this fails with a human-readable error rather than creating anything — never invent a price or silently retry as a different user.catalog_item_delete
ChatGPTPermanently delete a single catalog item by UUID. This cannot be undone — there is no soft delete and no restore, and this includes its pricing, custom fields, and bundle composition. Documents already sent that reference this item are unaffected (their line values were copied at send time). Before calling this, use
catalog_items_search or catalog_item_get to resolve the UUID to the item's name and SKU, if present, and explicitly ask the user to confirm deleting that specific item by name. Do not call this from an earlier request to find, view, or modify the item alone — only after the user has explicitly agreed to the deletion in this exchange. Call this once per item; there is no bulk delete.catalog_item_get
ChatGPTGet full detail for a specific catalog item by UUID — use once an item has been identified (for example via
catalog_items_search) and its complete pricing, custom fields, or bundle composition are needed. Each pricing block (default_pricing, and each variant's pricing entries) reports tiers when the item is priced by quantity — in that case price alone is not the amount to quote, use the tiers instead. billing_period is set only when billing_type is "recurring"; otherwise ignore it. variants lists the item's purchasable configurations (usually one), each with its own SKU, status, and custom fields (up to 200). bundle_items, when present, lists what the bundle contains — each entry is either a reference to another catalog item (with its own pricing) or a one-off custom line (flat price/currency, no catalog reference). Customer-facing bundle customization rules are not included here.catalog_item_update
ChatGPTUpdate fields on an existing catalog item by UUID. This is a write operation — call
catalog_item_get first, show the user a before → after comparison of what will change (price especially), and explicitly ask them to confirm this specific change. Do not call this from an earlier request that only found or viewed the item — only after the user has explicitly agreed to this exact change in this exchange. Every field is optional — set only the ones that should change. A field that is left out, or explicitly set to null, is left untouched — null is not a way to clear a field's current value except where a field's own description says otherwise. custom_fields, when set to an array, replaces the item's entire custom fields list (not a merge) — send an empty array to clear it. Only type=regular and type=bundle items can be updated through this tool; calling it on a "custom" item fails with a clear error rather than changing anything. Bundles cannot be created here — use catalog_item_create with type: "bundle" for that. bundle_items, when set, replaces the bundle's entire composition (not a merge) and can only be set on an item that is already a bundle — setting it on a regular item fails with a clear error rather than converting it, and it cannot be an empty list (there is no way to clear a bundle's composition through this tool). Each line is either a reference to an existing regular catalog item (kind: "catalog_item", with its uuid — this fails with a clear error if the uuid doesn't resolve to an existing regular item, rather than silently dropping the line) or a one-off custom line (kind: "custom", with its own title/price/currency) — see catalog_item_create's bundle_items for the full shape. Leave bundle_items out entirely to leave a bundle's composition unchanged; this tool never changes an item's type. This fails if the bundle has customer-facing configuration (selection groups and/or rules) that reference its current lines by id, since replacing the composition risks breaking those references. For flat pricing, set price_configuration.price. For quantity-tiered pricing, set price_configuration.tiers instead — never invent a flat price for a volume-priced item. Set billing_type to "recurring" only when the item is charged on a repeating cycle, and always pair it with billing_cycle. price_configuration's sub-fields follow the same "leave it out to leave it unchanged" rule as the top-level fields — changing only price means sending price_configuration: {"price": ...} with nothing else in it. Never include pricing_model, billing_type, billing_cycle, or currency unless you intend to change that specific thing, and never guess a value for one of them from context — check catalog_item_get's response for the current value first if you're unsure. Including one of these with the wrong value silently changes it alongside the field you meant to update. For multiple items ("raise these 5 prices"), summarize the full change set for every item and get one explicit confirmation covering all of them before calling this tool repeatedly — cap this at roughly 20 items per run. For larger bulk repricing, point the user at catalog CSV export/import instead. If the workspace's plan doesn't include Product Catalog, or the caller's role can't edit the catalog, this fails with a human-readable error rather than changing anything — never invent a result or silently retry as a different user.catalog_items_search
ChatGPTSearch the workspace's product catalog by free text across item name, SKU, description and category name, with optional filters. Use this to identify an existing catalog item before quoting its price or adding it as a line item. A query with no matches returns an empty list — treat that as "nothing found," not an invitation to guess a price or an item yourself.
pricing_model and billing_type are independent — read both. pricing_model says whether price is a flat unit amount ("fixed") or depends on quantity tiers ("volume_based" — get tier detail from catalog_item_get, and never present its price as a flat unit price). billing_type says whether that amount is charged once ("one_time"), per billing_period ("recurring"), or has no defined billing cadence ("unspecified"). A "volume_based" item can also be "recurring". Call catalog_item_get once a specific item has been identified — for example by an exact SKU, an unambiguous search result, or the user picking one of the candidates — when full tier or bundle detail is needed. If no single result is clearly the one the user meant, list the candidates rather than choosing silently. Include sku and, when available, price with billing_period when applicable. For a "volume_based" candidate, say it's volume-priced instead of quoting price as a flat amount.contacts_create
ChatGPTCreate a contact in the workspace address book from an email address, and return it with its
id, the contact id that recipients_add_cc and recipients_reassign take. The contact stays in the workspace address book after this call, so confirm the address with the user before calling. contacts_list resolves an address the workspace already knows; call this only when it returns no contact.contacts_list
ChatGPTResolve an email address to the contact it belongs to. Use it to get the
contact_id that recipients_add_cc needs, or the new_contact_id that recipients_reassign needs. For someone already on the document, skip this lookup: documents_details_get returns contact_id on each recipient alongside the recipient's own id. The match is on the full email address and nothing else: there is no search by name, by company, or by part of an address. When the user names a person without an email, ask for the email rather than guessing one. Returns no contact when the workspace address book holds none for that address; use contacts_create to add one.contacts_search
ChatGPTSearch the current workspace's contacts by first name, last name, or company. This tool does not search by email address; use contacts_list for an email address instead. Results can contain several contacts with the same name, so confirm which contact the user means before making a change. To add a returned contact as a CC, pass its id to recipients_add_cc as contact_id. To replace a signer with a returned contact, pass its id to recipients_reassign as new_contact_id.
create-document-edit-token
ChatGPTUse this tool to obtain an editing session token (e-token) for a specific document. The token is required by the editor widget to render the document in the chat. Call this tool after document creation to initialise the editor view. If the document is not yet in draft status the tool will return an error — retry up to 3-5 times with a short delay between attempts.
create-document-from-markdown
ChatGPTCreate document from markdown in PandaDoc tool Use this tool to create a new document in PandaDoc when there is only text representing the document content. Document content must be generated according to the guidelines below. The response includes a 'link' field with a direct URL to open the created document in PandaDoc. Document creation is asynchronous. After this tool returns, the document starts in
UPLOADED status and transitions to DRAFT after some time (or to ERROR if creation fails). The document must be in DRAFT status before it can be edited or sent. Markdown guidelines You can use standard CommonMark and GitHub-Flavored Markdown (tables, strikethrough, etc), plus the following custom extensions: Custom Syntax Extensions 1. Variables Variables are placeholder values that the document creator fills in PandaDoc before sending to recipients. Prioritize variables over fields for any value that the sender controls or pre-fills, even if it may be visible to recipients. Syntax: [VariableName] or [Variable.Name] or [Multi.Part.Variable] - Can include underscores, numbers, and multiple dot-separated parts Use variables for values controlled by the document creator: - Document metadata: [Effective.Date], [Agreement.Number], [Contract.Value] - Company/sender information: [Company.Name], [Company.Address] - Pre-calculated values: [Invoice.Total], [Discount.Amount] - Recipient information already known: [Recipient.CompanyName], [Recipient.FirstName] Key principle: If the sender controls the value, use a variable. 2. Fields Fields are interactive form elements that recipients fill in or interact with during the signing process. Recipients see these as input boxes, checkboxes, or signature areas. Use fields for values controlled by the recipient: - Recipient signatures: [[signature]] - Recipient personal data they must enter: [[text]], [[email]], [[phone]], [[date]] - Recipient choices/consents: [[checkbox]] - Information only the recipient knows or decides Key principle: If the recipient controls the value, use a field. Fields can be prefilled with default values, but are typically left empty for the recipient to fill. Syntax: [[field_type attributes]] Field Types: - text - Text input field - email - Email input field - phone - Phone number input field (`format` is required — see below) - number - Number input field - date - Date input field - checkbox - Checkbox field - signature - Digital signature field - dropdown - Dropdown selection field (`option` is required — see below) Attributes (HTML-style): - required="true" - Makes field required - placeholder="text" - Placeholder text - checked="true" - Pre-checked (checkbox only) - value="timestamp" - For date fields, use UNIX timestamp with millisecond precision (e.g., value="1718406000000"). For other fields, use plain text (e.g., value="John Doe"). - format="US" or format="international" - Required for `phone` fields. Must be exactly "US" or "international". There is no default — omitting it causes a validation error. - date_format="yyyy/MM/dd" - Date format in ICU notation (e.g., "dd/MM/yyyy", "MM-dd-yyyy"). Defaults to "yyyy/MM/dd" if omitted. - option="Text" - Required for `dropdown` fields. Repeatable — add one per option (e.g., option="Yes" option="No"). To assign a stable UUID to an option, use option="uuid:Text" format. - id="Client_Text1" - Specify an external ID that describes who should fill this field and what it represents (e.g., id="Client_Signature", id="Landlord_FullName", id="Buyer_Email"). Use the pattern <RecipientRole>_<FieldPurpose> so the field can later be assigned to the correct recipient. Multiple fields MAY share the same ID (they'll be synced — when one is filled, all are filled with the same value), but they MUST have the same type and attributes. Examples: - [[text placeholder="Enter name"]] - [[email required="true" placeholder="Email address"]] - [[phone format="US"]] …create-document-from-template
ChatGPTUse this when the user wants to generate a new PandaDoc document from an existing template they have already chosen (e.g. "draft an NDA from the Standard NDA template for alice@example.com", "create a Sales Contract from template TPL-123 for these recipients"). Returns the new document's id, name, status, and links; the document is created in
document.uploaded and transitions to document.draft once PandaDoc finishes processing. Before calling this, you must know the template_uuid and have at least one recipient. If the user has not named a template, first call get-templates to find one. To discover the roles, fields, and variables the template expects, call get-template-details and map recipient roles, field values, and variable values from that schema. Do not use this to: edit an existing document (use update-document or related update tools); create a document from raw markdown (use create-document-from-markdown).delete-document-recipient
ChatGPTUse this tool to remove a recipient from a document. Requirements: - recipient_id is required — obtain it from get-document-recipients or document details.
documents_archive
ChatGPTArchive a document by ID. The document moves to the archive, reversible instead of destroyed.
documents_audit_trail_get
ChatGPTAudit trail for one document: who viewed or signed it and when, from which IP address. Use it for disputes and compliance checks. Returns only the first page of entries.
documents_content_edit
ChatGPTEdit an existing PandaDoc document from a natural-language instruction. Provide the document_id and a complete edit instruction, including relevant context that helps execute the request without asking the user a follow-up question. The tool is non-interactive: it never asks clarifying questions. If the instruction cannot be mapped to an action, the response has success=false and code=non_executable. Edits apply asynchronously — when success=true, treat the edit as accepted and do not immediately re-fetch or compare document content to verify the change.
documents_content_get
ChatGPTReturns the textual content of a document in plaintext or markdown format. If the content is not ready, returns
{retry_after: N} where N is seconds to wait before retrying.documents_create
ChatGPTCreate document Create a new PandaDoc document. Pass a single
request object and set its source to choose how the document is created: - source: "template" — from an existing template. Required: template_uuid. Also accepts name, recipients, fields, tokens, tags, images, pricing_tables, tables, texts, folder_uuid, owner, detect_title_variables, content_placeholders. - source: "markdown" — from markdown content. Required: name, document_markdown. Also accepts recipients (individual recipients only; groups are not supported), role_fields, folder_uuid. - source: "file" — from a downloadable PDF or DOCX. Required: name and exactly one of url or file_uuid. Also accepts recipients, parse_form_fields, fields, tokens, tags, folder_uuid, owner. The schema is polymorphic on source: each source accepts only its own parameters. Passing a parameter that belongs to another source is rejected by validation, so you never need to guess which fields are ignored. Not for editing an existing document — use documents_update for that. Asynchronous creation Document creation is asynchronous for every source (template, markdown, and file). A successful tool response means creation was accepted, not that the document is ready. The document starts in Uploaded and becomes Draft once it is ready. After calling this tool: 1. Poll documents_status_get until it reports Draft, or until it returns an error. 2. If Draft, the document is ready to edit, send, or fetch details/content. 3. If documents_status_get returns an error, creation failed (invalid file, markdown conversion failure, validation errors, etc.). Report error.detail and do not call details/content/edit/send on it. This is terminal — error.retryable is false, so stop polling. 4. While status is still Uploaded, do not assume success and do not call tools that require a ready document. A failed creation is reported for roughly 8 hours. After that a status lookup reports the document as not found — treat that as the same terminal failure, not a reason to resume polling. Template Create a document populated from an existing PandaDoc template. Requires template_uuid. Recipients are optional — omit them to use template defaults or to add them later. If the template isn't known yet, call templates_list first, then templates_details_get to discover its roles, fields, and variables. Optionally set fields, tokens, pricing tables, recipients, and other template data. File Create a document from a PDF or DOCX using exactly one file reference: - url — a directly downloadable URL with no authentication or HTML interstitial. - file_uuid — the reference returned by the files_request_upload_url tool. First upload the file bytes to its presigned_url with an HTTP PUT, then call this tool with the returned file_uuid. The uploaded file is checked for ownership, allowed type, size, and malware before document creation. Presigned S3/GCS/Azure URLs or direct CDN links work best for url. Google Drive and Dropbox share links do not work because they return HTML instead of the file. To parse fillable PDF form fields, set parse_form_fields: true and provide fields mapping every form field name to a recipient role — omitting any causes failure. Markdown Create a new document in PandaDoc from markdown when there is only text representing the document content. Document content must be generated according to the guidelines below. The response includes a document_url field with a direct URL to open the created document in PandaDoc. Markdown guidelines You can use standard CommonMark and GitHub-Flavored Markdown (tables, strikethrough, etc), plus the following custom extensions: Custom Syntax Extensions 1. Variables Variables are placeholder values that the document creator fills in PandaDoc before sending to recipients. Prioritize variables over fields for any value that the sender controls or pre-fills, even if it may be visible to recipients. Syntax: `[VariableName]…documents_details_get
ChatGPTRetrieve a document's full structure by document_id: name, status, dates, version, reference number, creator, template, recipients, fields, variables, tokens, tags, pricing/grand total, and linked objects. Use to inspect a document before acting on it. Recipients carry
recipient_type (signer, CC, approver) and, when the person is a workspace contact, the contact_id the contact tools take. Does not return extracted metadata — use documents_metadata_batch_get for that; for the overall status only, use documents_status_get.documents_edit_token_create
ChatGPTUse this tool to obtain an editing session token (e-token) for a specific document. The token is required by the editor widget to render the document in the chat. Call this tool after document creation to initialise the editor view. If the document is not yet in draft status the tool will return an error — retry up to 3-5 times with a short delay between attempts.
documents_fields_assign
ChatGPTAssign, reassign, or unassign document fields to recipients. The document must be in draft status. Provide a list of field-to-recipient mappings. Set recipient_id to null to unassign a field. Use get document details to obtain field UUIDs (fields[].uuid) and recipient IDs (recipients[].id). Once a field is assigned, that recipient becomes a signer for it. If it's unclear which recipient a field belongs to, ask the user before assigning.
documents_link
ChatGPTAssociate a document with a CRM object such as a HubSpot deal, so the document appears in that CRM record. Works on a document in any status.
provider and entity_type identify the CRM object. Common pairs: hubspot with deal; salesforce-oauth2 (or salesforce-oauth2-sandbox) with opportunity, lead, account, or contact; pipedrive with deal, organization, or person; ms-dynamics with opportunity, lead, contact, quote, or competitor. entity_id is the object's id in that CRM (for HubSpot, the deal id). The CRM integration must be connected in the workspace. A document can be linked to several CRM objects with separate calls.documents_list
ChatGPTPaginated document listing with structured filters: status, folder, tag, free-text search, sorting, and created/completed date ranges. Examples: 'list 50 Draft docs' · 'documents in folder <folder_uuid> tagged onboarding' · 'page 3 sorted by date_modified' For natural-language queries, prefer `
ai_search` if available.documents_metadata_batch_get
ChatGPTUse to read the business terms extracted from documents — counterparty, contract value, dates, renewal terms — without fetching and re-reading their full text. Handles 1-40 documents per call, so pass a one-element
document_ids for a single one. Narrow the response with field_keys when only certain terms matter. Extraction generally runs once a document is completed, so a document still being worked on may have nothing to return yet. Each document reports its own outcome, so one failure does not lose the rest: ok carries that document's fields, extraction_pending should be retried after retry_after seconds, extraction_not_started means the document is not completed yet, extraction_failed is terminal (contact support), not_found and access_denied mean the document cannot be read, and internal_error is safe to retry for that document alone.documents_reminder_send
ChatGPTSend a reminder to recipients of a document that is out for signature, so the ones who have not completed their part are prompted again. The document must be in Sent or Viewed status. Reminders reach real people by email and/or SMS, so confirm with the user which recipients to remind before calling. Take recipient ids from the document's details; recipients left out of the call are not reminded. To word the email yourself, pass subject and message at the top level of the call — they apply to every recipient in it. This call can succeed as a call and still deliver nothing: it always answers with one entry per requested recipient, carrying a status for both email and SMS. Report a reminder as sent only where that status is
sent. Where a method you requested has any other status, name the recipient, the method and the reason from detail, and do not call the request successful. A method you did not request always reports error with "delivery method is not selected" — that is expected, not a failure, and must not be mentioned to the user.documents_search
ChatGPTFull-text search with status/date filters. Examples: 'NDA in completed docs' · 'modified 2026-01-01–2026-03-31' · 'sent docs Q1 2026' For natural-language queries, prefer `
ai_search` if available. If the user refers to a document by name and an ID is needed for a downstream operation, use this tool to resolve the name to an ID first. Do not ask the user for a document ID before attempting this lookup.documents_send
ChatGPTSend a document to its recipients. The document must be in Draft status. After sending, the status changes to Sent and recipients receive a notification. Use skip_unfilled_variables to send even when some variables are empty. Pass selected_approvers only if documents_details_get shows an
approval_execution; if absent, send without it. Always confirm with the user before sending.documents_status_change
ChatGPTManually change a document's status. Only these transitions are allowed: Completed, Paid, Expired, or Declined. Status changes are restricted based on the current document status. Other statuses (such as Sent, Viewed, Approved) are set automatically by the system and cannot be set with this tool.
documents_status_get
ChatGPTRetrieve the overall document status (e.g. Draft, Sent, Completed, Expired). Some statuses are set automatically by the system: Sent (when the document is sent), Viewed (when a recipient opens it), Approved/Rejected (via approval workflows). For per-recipient signing progress use documents_details_get. Right after creating a document it may still be processing — if so, wait briefly and check again before acting.
documents_summary_get
ChatGPTReturns a summary for the specified document. Supports three granularity levels: detailed, short, or headline. If not ready, returns
{retry_after: N} where N is seconds to wait before retrying.documents_update
ChatGPTUpdate a document. Document must be in Draft status. You can update text blocks, fields, and other document properties. After creating a new document, wait for it to reach Draft status before updating. To modify individual recipients, use
recipients_* tools — the recipients param here replaces the entire list.documents_view
ChatGPTUse this tool only when the user explicitly requests to open the document in the chat. Opens a DRAFT document in the editor widget so the user can interact with it directly inside the chat. Returns full document details including a 'link' field with a direct URL to open the document in PandaDoc. Don't use it automatically to refresh the document widget. Don't offer to open the document or review it after document creation.
fetch
ChatGPTFetch the full markdown content and metadata of a PandaDoc document by id or URL. Accepts an id returned by
search or a PandaDoc URL.files_request_upload_url
ChatGPTCreate a short-lived upload slot for a PDF or DOCX file. Upload the file bytes to the returned presigned URL with an HTTP PUT request, then pass file_uuid to documents_create with source set to "file".
fill-variables
ChatGPTUse this tool to fill variable values on a PandaDoc document. Variables are placeholders defined in the document that can be replaced with actual values. Provide a list of variable name/value pairs to populate.
get-audit-trail
ChatGPTFetches audit trail data for a given document id. As it is a V2 public api endpoint it requires a dedicated public api authorization token.
get-document-details
ChatGPTRetrieve full details of a specific PandaDoc document by its ID. Returns document metadata (name, status, dates, version, ref number), creator info, template, fields, variables, tags, recipients, grand total, linked objects, custom metadata, and a 'link' field with a direct URL to open the document in PandaDoc. Useful for inspecting a document after creation or before taking action on it.
get-document-status
ChatGPTUse this tool to get the status of a document in PandaDoc. This is useful after creating a document from markdown to ensure that document has been processed successfully and in DRAFT status. If the document is in UPLOADED status, retry with exponential backoff up to 3-5 times.
get-documents
ChatGPTRetrieve a paginated list of PandaDoc documents.
get-template-details
ChatGPTUse this when the user (or an upstream step) needs to inspect a specific PandaDoc template's schema — its roles, fields, variables (variables), pricing tables, content placeholders, tags, and metadata — usually as preparation for
create-document-from-template (e.g. "what roles does the Sales Contract template have?", "which variables does template TPL-123 expect?", "can I use the NDA template for an external signer?"). Returns the full template-details payload for one template id. Typical flow: call get-templates first to find the right id, then this tool to read the schema, then create-document-from-template with recipient roles, field values, and variable values mapped to that schema. Do not use this to: list/search templates (use get-templates); fetch a regular document (use get-document-details); or actually create a document (use create-document-from-template).get-templates
ChatGPTUse this when the user wants to discover, browse, or pick a PandaDoc template by name, tag, or folder (e.g. "what templates do we have?", "find the NDA template", "list templates tagged sales"). Returns a paginated list of templates with id, name, version, and timestamps. Pair a returned template id with
get-template-details to inspect roles/fields/variables, or with create-document-from-template to generate a new document. Do not use this to search documents (use get-documents), to fetch a template's roles/fields/variables (use get-template-details), or to create a document (use create-document-from-template).get-widget-context
ChatGPTReturns the widget context required by the widget to initialise. This tool is intended for widget use only.
quotes_update
ChatGPTUpdate one or more existing quotes on a document — sections, line items, prices, quantities, discounts, fees, and taxes. Up to 25 quotes per call; each quote is applied independently, so one quote's failure never affects the others. This tool cannot create a new quote, and a quote cannot be created at document-creation time either — only existing quotes (already present on the document) can be updated. Destructive replace, not a diff: including
sections replaces the quote's ENTIRE section list — any current section whose id is left out is REMOVED. The same applies one level down: including items on a section replaces that section's ENTIRE item list — any current item whose id is left out is REMOVED (pass an empty list to clear all items from a section). To change only part of a quote/section, first fetch its current state and include every section/item you want to keep, changing only the fields that need to change. Fields left out of an included section/item are left untouched; a field explicitly set to null where the schema allows it (name, billing_frequency, contract_term) clears that field instead. options (on a line item) and settings (on a section or quote) are all-or-nothing: when included, every property in them must be given a value — there is no partial update of a single property inside these objects. Returns one result per requested quote, in the same order as the request, keyed by id and discriminated by status: ok carries the quote's full state after the update; not_in_document (the quote id is not linked to this document, or the caller lacks edit access to it), not_found (no such quote), and conflict (the quote was updated concurrently — refetch and retry) are per-quote outcomes that leave the other quotes in the batch unaffected; internal_error is an isolated per-quote failure safe to retry on its own.recipients_add_cc
ChatGPTAdd a CC (non-signing) recipient to a document. Requires an existing contact ID, which is not the same as a recipient id. For someone already on the document, take
contact_id from that recipient in documents_details_get. Otherwise resolve their email with contacts_list; when it finds no contact, contacts_create can add one after the user confirms the address. Cannot add to Expired or Declined documents. Adding a contact that is already a CC recipient is silently ignored. This tool only adds CC recipients; signers must be set via documents_create or documents_update.recipients_delete
ChatGPTRemove a recipient from a document. Signers can only be removed in Draft status. CC recipients can be removed in any status except Expired/Declined.
recipients_edit
ChatGPTUpdate one recipient's details (email, name, phone, company, address, redirect) in place. Signers can be edited in Draft, Waiting Approval, Approved, Rejected, Sent, or Viewed status. A signer's email cannot be changed after they have signed. CC recipients can be edited in any status except Expired or Declined. Get recipient_id from document details first. To change an email to one that belongs to another contact, resolve the new email with
contacts_list, then call recipients_reassign with the returned contact id as new_contact_id.recipients_reassign
ChatGPTReplace a signer with another contact.
recipient_id is the signer being replaced, from the recipient's id in document details. new_contact_id is the replacement's contact ID, never a recipient id: take it from that recipient's contact_id in document details when they are already on the document, and otherwise resolve their email with contacts_list; when it finds no contact, contacts_create can add one after the user confirms the address. Transfers all assigned fields to the new signer. The original signer is removed. Cannot reassign already-signed recipients. To just fix a signer's email/name, use recipients_edit.search
ChatGPTUse this when a request requires searching the user's PandaDoc workspace for existing documents by keyword, topic, title or document context. Returns matching contracts, proposals, quotes, and other PandaDoc documents.
send-document
ChatGPTUse this tool to send document to recipients. Document must be in draft status. If the document is not in draft status, it won't be sent. After document is sent it will be moved to 'sent' status and recipients will receive notification and document will appear in recipients list.
templates_create
ChatGPTCreate a new template from a PDF URL. Provide a secure (HTTPS) publicly accessible URL to the PDF document.
templates_delete
ChatGPTDelete a template by ID. The template is moved to the deleted state and no longer appears in normal listings (it can still be found by listing with the deleted filter). Confirm with the user before deleting.
templates_details_get
ChatGPTInspect a template's schema — roles, fields, variables, pricing tables, content placeholders, tags, metadata — usually to prepare a
documents_create call (e.g. 'what roles does the Sales Contract template expect?'). Typical flow: templates_list -> this tool -> documents_create. Not for listing templates or fetching a regular document.templates_duplicate
ChatGPTCreate a copy of an existing template within the same workspace. Optionally provide a
name for the copy; when omitted or empty, a name is auto-generated from the source template. Returns the new template's id and name, plus the source template id.templates_list
ChatGPTDiscover, browse, or pick a template by name, tag, or folder (e.g. 'what templates do we have?', 'find the NDA template'). If the user refers to a template by name and an ID is needed for a downstream operation, use this tool to resolve the name to an ID first. Do not ask the user for a template ID before attempting this lookup. Returns a paginated list of templates. Pass a returned
id as templates_details_get's template_id to inspect roles/fields/variables, or as documents_create's template_uuid to generate a document. Not for searching documents (use documents_list) or creating one.templates_update
ChatGPTUpdate an existing template's CUSTOM variables (tokens) and/or its signer roles. Provide
tokens to upsert variables by name, and/or roles to replace the full list of roles. Inspect current roles and variables with templates_details_get first. At least one of tokens or roles must be provided. This tool does not rename a template or edit its content/pages. A newly created template needs a few seconds to finish processing before it can be updated; if an update fails immediately after creation, wait briefly and retry. This returns only a confirmation, not the updated template — to read the UUIDs of any newly created roles, call templates_details_get afterwards.update-document-recipient
ChatGPTUse this tool to update an existing recipient on a document. Requirements: - recipient_id is required — obtain it from get-document-recipients or document details. Constraints: - Only phone, email, first name and last name can be changed
view-document
ChatGPTUse this tool only when the user explicitly requests to open the document in the chat. Opens a DRAFT document in the editor widget so the user can interact with it directly inside the chat. Returns full document details including a 'link' field with a direct URL to open the document in PandaDoc. Don't use it automatically to refresh the document widget. Don't offer to open the document or review it after document creation.
widget_context_get
ChatGPTReturns the widget context required by the widget to initialise. This tool is intended for widget use only.
pandadoc_documents_content_get
Claudepandadoc_documents_create
Claudepandadoc_documents_create_from_markdown
Claudepandadoc_documents_details_get
Claudepandadoc_documents_list
Claudepandadoc_documents_search
Claudepandadoc_documents_send
Claudepandadoc_documents_status_change
Claudepandadoc_documents_status_get
Claudepandadoc_documents_summary_get
Claudepandadoc_documents_update
ClaudeCapabilities
WritesInteractive
Example Prompts
Click any prompt to copy it.
Links
App Stats
76
Tools
1
Prompts
ChatGPT, Claude
Platforms
Category
Document SigningWorks with
ChatGPT
Claude
Data refreshed daily