- Brand
- PandaDoc
- Category
- Productivity
- Primary Subcategory
- E-Signature & Contract Execution
Integration details
Description
Create any agreement in ChatGPT and send it for e-signature without leaving the conversation. Describe what you need, watch it take shape, add your recipients, and send. Your AI draft becomes a polished, signature-ready agreement automatically.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- E-Signature & Contract Execution
- Secondary Subcategories
- None listed
- Brand
- PandaDoc
- Access
- Account required
- First tracked
- 2026-09-01
- Tool count
- 49
- Market
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Agent Discoverability
ChatGPT Plugin Discovery ScoreYour score is coming
ChatGPT now suggests Plugins on its own when they match a user's request.Your Plugin Discovery Score measures how often yours appears, and it will show here as soon as it’s ready.
What discovery looks like
Get alerts for PandaDoc
Get updates when PandaDoc’s Discoverability Score or category rank changes.
Competing in ChatGPT E-Signature & Contract Execution
View Category49 tools agents can invoke
Add 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_add_cc
Archive a document by ID. The document moves to the archive, reversible instead of destroyed.
documents_archive
Assign, 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_fields_assign
Use 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_metadata_batch_get
Manually 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_change
Create 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_create
Create 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_create
Create 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_create
# Create 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]` 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. > **Making a recipient a Signer — three things must line up.** A recipient becomes a Signer only when a field is assigned to their role. To assign one, all three of these must agree: > > 1. Give the field an `id` in `document_markdown` — e.g. `[[signature id="Signer_Sig"]]`. > 2. Add a recipient whose `role` matches — e.g. `{ "email": "signer@example.com", "role": "Signer" }`. > 3. Map the role to that id in `role_fields` — e.g. `[{ "role": "Signer", "field_ids": ["Signer_Sig"] }]`. > > A bare `[[signature]]` with no `id`, or a recipient that no `role_fields` entry references, is added as **CC** and cannot sign. Always set an `id` on signature/date fields the recipient must complete and reference it from `role_fields`. **Use fields for values controlled by the recipient:** - Recipient signatures: `[[signature id="Signer_Sig"]]` (see the Signer callout above — a signature with no `id` and no `role_fields` mapping leaves the recipient as CC) - 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. **This is also the only value `role_fields[].field_ids` may reference** (see below) — a field with no `id="..."` cannot be pre-assigned to a role. **Assigning fields to roles via `role_fields`:** to pre-assign a field to a recipient's role at creation time, give the field an `id="..."` in `document_markdown`, then reference that exact same string in `role_fields[].field_ids`. A `field_ids` value that does not match any `id="..."` in `document_markdown` is rejected — never invent a `role_fields` value without first setting the matching `id="..."` on the field: ```text document_markdown: "Signed: [[signature id=\"Signer_Sig\"]]" role_fields: [{"role": "Signer", "field_ids": ["Signer_Sig"]}] ``` **Examples:** - `[[text placeholder="Enter name"]]` - `[[email required="true" placeholder="Email address"]]` - `[[phone format="US"]]` - `[[phone format="international"]]` - `[[number]]` - `[[date required="true" value="1718406000000"]]` - `[[date date_format="dd/MM/yyyy"]]` - `[[checkbox checked="true"]]` - `[[dropdown option="Yes" option="No"]]` - `[[dropdown option="Yes" option="No" value="Yes" placeholder="Choose..."]]` **Important:** Fields with the same ID must have the same type and attributes. For example, you cannot have `[[text id="Field1"]]` and `[[email id="Field1"]]` in the same document as well as `[[text id="Field2" placeholder="Full Legal Name" ]]` and `[[text id="Field2"]]` because they have different attributes. **Dropdown constraints:** - At least one `option` attribute is required. - Option texts must be unique within the dropdown. - If `value` is set, it must match one of the defined option texts exactly; otherwise a validation error occurs. ##### 3. Standalone Checkboxes Checkboxes use GFM syntax but can appear anywhere, not just in lists: - `[ ]` - Unchecked - `[x]` - Checked - Can be used inline, standalone, or in task lists ##### 4. Page Breaks **Syntax:** `---` (three hyphens) creates a page break. **IMPORTANT:** Page breaks should be rare and intentional. Most documents don't need page breaks. Only use `---` when content **must** be on separate pages for a specific reason: - Legal/structural requirement - Document structure demands it **Do NOT use `---`:** - Between sections (use headings: `## Section Title`) - As visual decoration (use blank lines) - Simply because there's a section transition ##### 5. Pricing Tables A pricing table is a table of line items followed by a list of totals, wrapped in HTML comment markers that the reader never sees. Use one whenever the document quotes prices: quotes, proposals, order forms, invoices. **Without the markers it is an ordinary table** — the numbers come back as plain text, with no currency, no quantities and no recalculation. **Syntax:** ```markdown <!-- pandadoc:pricing-table name="Services" --> | Name | Description | Price | QTY | Tax | Subtotal | |------------|-------------|-------------|-----|------|-------------| | Consulting | Senior rate | 2000.24 USD | 3 | 23 % | 6000.72 USD | * Subtotal: 6000.72 USD * Discount: -10 % * Total: 5400.65 USD <!-- pandadoc:end-pricing-table --> ``` **Columns** are matched by name: - `Name` — **required**, on every row. Text, may be formatted. - `Price` — **required**, on every row. An amount, e.g. `2000.24 USD`. - `Description` — text, may be formatted - `SKU` — text - `Cost` — an amount - `QTY` — a number. Added for you (as 1) if the column is left out. - `Tax` — a percentage (`23 %`) or an amount (`50.00 USD`) - `Discount` — a percentage (`-10 %`) or an amount (`-50.00 USD`), written negative - `Subtotal` — an amount. Added for you if the column is left out. An empty `Name` or `Price` cell is an error, and a column not in this list is kept as text under the name you wrote. `Tax` and `Discount` may each be a percentage or money, but a single column has to agree with itself: one mixing `-10 %` and `-5.00 USD` is an error. **Footer totals** go in a list directly under the table as `Name: value`. Only `Subtotal`, `Discount`, `Tax`, `Total` and `Total QTY` are accepted; any other total is an error. **The name** builds the document's tokens: a table named `Services` with a `Total` gives you `[Services.Total]` to use in any paragraph. Two tables may not share a name; an unnamed table takes the next free `Pricing Table N`. **The end marker** may be left out for a single table, which then reads as the table after the marker plus the totals after that. It is **required** for a table in sections, and it stops an unrelated table further down being swallowed into the prices. **Sections and optional items** — a heading above a table titles that group of line items, and every section must describe the same columns. A checkbox before the name offers the item rather than including it; no box means it is simply part of the quote. `[optional]` on a section heading lets the reader drop the whole section, `[choose one]` limits it to a single ticked row: ```markdown <!-- pandadoc:pricing-table --> ### Setup | Name | Price | |---------|------------| | Install | 500.00 USD | ### Add-ons [optional] | Name | Price | |-----------------------|------------| | [ ] Extended warranty | 200.00 USD | | [x] Support plan | 100.00 USD | * Total: 600.00 USD <!-- pandadoc:end-pricing-table --> ``` **Currency** comes from the amounts themselves, which must all agree on one. A currency code (`2000.24 USD`) always names it; a symbol only when it belongs to a single currency — `zł` is Poland's alone, but `$` is shared by many and names none. **Not supported in a Markdown pricing table:** photos, tiered ("buy 10+") prices, per-item editable quantities, column width, lock and colour, and the CRM datasource. Those are set in the PandaDoc editor. ##### 6. Money Formatting By default amounts are read the Anglo way — `.` splits decimals, `,` groups thousands, and the currency code follows the number (`1,234.56 USD`). If the document writes money any other way, say so in YAML front matter at the very top of the file: ```markdown --- pandadoc: money: display_as: symbol position: before separate_with_space: true precision: 2 decimal_delimiter: comma thousand_delimiter: space --- ``` With that block, `zł 2 000,24` reads as two thousand. All six settings are required when the block is present: - `display_as` — `no_code`, `symbol`, `code`, `code_and_symbol` - `position` — `before`, `after` - `separate_with_space` — `true`, `false` - `precision` — a number of decimal places, e.g. `2` - `decimal_delimiter` — `dot`, `comma`, `space`, `quote`, `no_delimiter` - `thousand_delimiter` — same values as `decimal_delimiter` These say **how** money is written, not which currency it is. Quantities and percentages carry no currency but are written the same way, so a document splitting decimals with a comma writes `1,5` and `7,25 %`. Digits that are not grouped in threes are an error rather than a guess, so write amounts consistently with the settings you declared. **Note:** front matter opens with `---`, which is also the page break. The block is only read as front matter at the very top of the file naming `pandadoc`; a `---` anywhere else stays a page break. ### Limitations (Features NOT Supported) **Do NOT include:** - Raw HTML, including `<br>`, `<u>`, and `<div>` - Blockquotes inside lists - Images inside links inline with text (e.g., `[](link)`) - Merged table cells **Field syntax rules:** - Field types must be lowercase and match the closed set exactly (`text`, `email`, `phone`, `number`, `date`, `checkbox`, `signature`, `dropdown`). Capitalized or otherwise altered forms are not recognized. - The only valid syntax is `[[field_type attributes]]`. Forms like `[[Signature|Signer]]`, `[[signature:sig_a]]`, `[[s:Owner1]]`, and `[[signature_1]]` are not recognized — use `[[signature id="Signer_Signature"]]` instead. - Fields sharing the same `id` must have the same field type — a mismatched type is rejected. `signature` fields cannot share an `id` with any other field, including another `signature` field. - Every value passed in `role_fields.field_ids` must match the `id` attribute of a field present in `document_markdown`.
documents_create
Use 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_edit_token_create
Create or replace the Submit for approval configuration on a template. A template has at most one configuration; this writes the full desired end-state. Conditional approvals are not supported. If the template already has them, the request is rejected and the existing configuration is left unchanged. After this, create a document from the template; `documents_details_get` then shows `approval_execution` to copy into `documents_send`.
templates_approval_workflow_update
Create a new template from a PDF URL. Provide a secure (HTTPS) publicly accessible URL to the PDF document.
templates_create
Permanently 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_delete
Permanently 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_delete
Remove 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_delete
Delete 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_delete
Create 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_duplicate
Edit 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_edit
Update 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_edit
Fetch the full markdown content and metadata of a PandaDoc document by id. Accepts an id returned by `search`.
fetch
Resolve 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_list
Inspect 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_details_get
Get 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_get
Get 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_tree
Get 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_get
Audit 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_audit_trail_get
Returns 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_content_get
Retrieve a document's full structure by document_id. Use this to see who the recipients are (names, emails, roles, signing progress), and to read fields, variables, tokens, tags, pricing/grand total, linked objects, name, status, dates, version, reference number, creator and template. Also use it 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_details_get
Retrieve only the overall document status (e.g. Draft, Sent, Completed, Expired); returns just id and status. 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). Does not return recipients, fields or any other document content. For recipients (names, emails, roles, 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_status_get
Returns 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_summary_get
Returns the widget context required by the widget to initialise. This tool is intended for widget use only.
widget_context_get
Associate 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_link
Paginated 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_list
Discover, 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_list
Replace 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`.
recipients_reassign
Create 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".
files_request_upload_url
Use 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.
search
Search 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.
contacts_search
Full-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_search
Search 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. Use `catalog_category_tree` instead to see the complete category tree.
catalog_categories_search
Search 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.
catalog_items_search
Send 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_send
Send 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_reminder_send
Rename 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_category_update
Update 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_item_update
Update 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.
documents_update
Update 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.
quotes_update
Update 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.
templates_update
Use 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.
documents_view
Recommended guideHow to get your ChatGPT Plugin suggestedFollow the practical steps agents use to find, shortlist, and choose your Plugin.Read guidePandaDoc ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve PandaDoc's ChatGPT Plugin discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
What are PandaDoc alternatives on ChatGPT?
As of 2026-11-02, PandaDoc competes with AddSign, Assinafy, Atlas, Attest by DataHubz, DocStudio, DocuSeal, Docusign, eSignatures.com and 11 more in ChatGPT E-Signature & Contract Execution, ranked by public Discoverability Score.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.