PandaDoc Attio Integration: The Complete Setup Guide

To set up the PandaDoc Attio integration, a workspace admin installs the PandaDoc app from Attio’s Apps and integrations settings, then two connections are made: each member connects their own PandaDoc account to create and view documents, and an admin adds a workspace connection with a PandaDoc API key to unlock workflow triggers. You need a PandaDoc Business plan to connect, and the app works on every Attio plan.

The install takes minutes. Making it a working system takes deliberate attribute mapping, templates built around those variables, and an honest plan for pricing, because Attio records do not carry line items into PandaDoc pricing tables the way CRM products do in the HubSpot or Pipedrive integrations. Across the 129 sales calls we analysed, manual document creation was the top pain in 82 of them, and the teams suffering most usually had their tools connected already. The software was linked. The system was not. This guide covers both.

Key takeaways

• The integration runs as an Attio app: an admin installs it from Apps and integrations, and it requires a PandaDoc Business plan. It is available on all Attio plans.
• There are two connection types and most stalled setups are missing one: member connections let people create and view documents, and the admin-level workspace connection (a PandaDoc API key) is required for workflow triggers.
• Documents are created from person, deal, and custom object records. Company records are not supported, so plan your system of record around that.
• Attio attributes map to PandaDoc variables automatically where possible, but only certain attribute types map, Record and Relationship attributes must be single-value, and Attio values overwrite existing data in matching PandaDoc fields.
• Line items do not transfer into pricing tables or quote builder blocks. Pricing lives in PandaDoc’s own catalog and tables; headline numbers come from deal attributes as variables.
• The Document status changed workflow trigger is the integration’s writeback story: it can advance a deal stage when a contract completes, but only through the workspace connection.

What the PandaDoc Attio integration actually does

Once installed and connected, the integration does four jobs:

1. Record data into documents. Attio attributes populate PandaDoc variables, so a proposal opens pre-filled with the client name, deal value, and dates exactly as they sit on the record. Attributes auto-map to matching PandaDoc fields where possible.
2. Documents from the record. From a person, deal, or custom object record, the team creates a document from a template through Quick actions or the record actions menu, confirms recipients suggested from the record, and sends, without leaving Attio. By default the document opens in an embedded builder inside Attio.
3. Status on the record. View documents shows every linked document with its live status (draft, sent, viewed, completed, declined, and so on), and a PandaDoc widget on the record page shows the most recent document’s status at a glance.
4. Workflows from document status. The Document status changed trigger fires an Attio workflow when a document is completed, viewed, declined, sent, or voided, optionally filtered to a single template. That is how a signed contract moves the deal stage on its own.

Notice what is not on that list: company-record support, line-item transfer into pricing tables, and manual linking of documents that already exist in PandaDoc. Those gaps are where configuration decisions matter most, and we cover each below. A partial integration is what produces the workaround culture where someone re-types CRM data into documents every few days: the pattern we call the human Zapier.

Before you install: prerequisites and decisions

Check the account requirements first:

• PandaDoc plan. Connecting Attio to PandaDoc requires a PandaDoc Business plan. The Attio side is available on all Attio plans.
• Admin to install. Only a workspace admin can install the app. Once installed, every member can use it, but each member connects their own PandaDoc account individually.
• Browser settings. Documents open in an embedded builder by default, and if the editor does not open, third-party cookies are the usual culprit. Admins can switch the whole workspace to “Open documents in new tab” in the app’s settings, which is also needed when templates include steps the embedded builder cannot run, such as collecting payment with Quote Builder.

Then make two decisions that are much cheaper to make now than after rollout:

• Which object is the system of record? Documents can be created from person, deal, and custom object records, but not from companies. If your proposals are driven by company-level data today, decide now whether deals or a custom object will own document generation, and make sure that object holds the attributes your documents need.
• Which attributes will feed the documents? Walk through your most-sent proposal and list every value in it that exists on the record. That list, not the full attribute set, is your variable scope. This is the same scoping discipline that a full PandaDoc implementation starts with, and skipping it is the number one reason integrations stall.

Step 1: Install the app and make both connections

In Attio, open the workspace menu, go to Apps and integrations, open PandaDoc, and click Install. That is the admin’s first job. The second is the part most setups miss: the app uses two separate connection types, and they do different work.

• Member connection. Under Member connections, each person clicks Connect, signs in to PandaDoc, and authorises. This is what lets them create and view documents from records. A member without a connection sees nothing useful.
• Workspace connection. An admin generates an API key in PandaDoc (Settings, then API and Integrations, with API and Webhooks enabled) and enters it in the PandaDoc app in Attio. This connection exists for one reason that matters a lot later: workflow triggers only work through it. Skip it and documents still generate fine, but the writeback half of the system silently does not exist.

Make both connections during setup, even if you are not building workflows on day one. The API key takes two minutes now and saves a confused afternoon later.

Step 2: Map attributes to variables, and respect the type rules

Attio attributes become PandaDoc variables, inserted in the editor by typing an open square bracket or from the Variables sidebar. Auto-mapping fills matching PandaDoc fields, with one behaviour to know: the Attio value overwrites whatever was already in the matching PandaDoc field. That is usually what you want, and occasionally very much not, so audit which template fields share names with mapped attributes.

Which attributes are available depends on the record type:

• People: first name, last name, company name, email, first phone number, and address parts (city, state, country, postcode).
• Deals: all system attributes, plus custom attributes of these types: text, number, currency, phone number, user, date, timestamp, and single-value record or relationship.
• Custom objects: text, number, currency, select, phone number, user, date, timestamp, and single-value record or relationship attributes.

Two rules fall out of that list. First, multi-select relationship data does not map: record and relationship attributes must be single-value. If your proposal needs a list of linked items, that list has to be assembled in PandaDoc, not pulled from the record. Second, only attributes that existed when the document was created can be used as variables, so settle the attribute structure before building templates, not after.

For every variable you plan to use, check the attribute is reliably populated on real records before the stage where the team creates documents. A variable mapped to a usually-empty attribute is worse than none, because the blanks it produces make the team distrust generation entirely. Where an attribute is often empty, fix the process rather than the template: make filling it part of an earlier pipeline stage, or drop the variable. A template with 10 dependable variables beats one with 30 theoretical ones.

Step 3: Build templates around the variables and recipient rules

With the variable list settled, build the templates that consume it: client and company names in the cover and agreement text, dates in the body, the deal value in the summary. The templates deserve the same rigour as the mapping: locked branding, reusable library sections, one master template per document type. Off-brand documents were a stated pain in 44 of the 129 calls we analysed, and an integration that fills ugly templates faster just produces ugly documents faster. That discipline is its own project, covered on our PandaDoc templates service page.

Recipients behave differently per record type, and two details catch teams out:

• From a deal, Attio suggests the people linked to the deal plus the deal owner. This is the smoothest path and another reason deals make a good system of record.
• From a person record, the person must have a first name, last name, and email before a document can be created at all, and, counterintuitively, creating the document does not add that person as a recipient. The team enters the recipient manually, so put that in the training, not in the small print.
• From a custom object, suggested recipients come through a relationship attribute, which is worth wiring deliberately if a custom object owns your document flow.

One more builder habit: if someone closes the embedded editor before the Review content step, no draft is saved. The team should treat document creation as one sitting, not something to half-finish.

Step 4: Handle pricing honestly: line items do not transfer

Here is the difference between this integration and PandaDoc’s deeper CRM integrations, and the thing to plan around: nothing in Attio flows into a PandaDoc pricing table or quote builder block as line items. With HubSpot or Pipedrive, products attached to the deal arrive in the pricing table with quantities and prices intact. With Attio, the integration maps single attributes, not product lists.

That is not a reason to abandon the integration. It is a reason to put pricing where it works:

• Keep the catalog in PandaDoc. Build your products, prices, and SKUs in PandaDoc’s catalog, and have pricing tables in the template pull from it. The team picks line items inside the document, from governed prices, instead of typing them. Our pricing tables guide covers how to structure the tables themselves.
• Use variables for totals and terms. A deal’s currency attributes map cleanly, so the contract value, monthly fee, or term length lands in body text and summary sections straight from the record. The itemised table is built in PandaDoc; the headline numbers still come from Attio.
• Step up to CPQ when rules enter the picture. If pricing involves bundles, conditional options, volume discounts, or approval-gated margins, a flat table is not enough regardless of integration. That is PandaDoc CPQ territory, and it runs entirely inside PandaDoc, so the Attio gap stops mattering.

What you should not do is let the gap push pricing into a spreadsheet that gets pasted into documents: that reintroduces the typos, stale prices, and ungoverned discounts the integration was meant to remove.

Step 5: Know the linking rules before you trust the tracking

Tracking is only as good as the linking rules, and Attio’s are specific:

• Deals: every document created from the deal appears on it. Clean and predictable.
• People: a document appears on a person record only when that person’s email is on the document as a recipient, collaborator, or approver. A document about someone, sent to someone else, will not show on their record.
• Companies: no document creation, no document viewing. If account managers live in company records, they need to click through to the deal or person to see paperwork.
• Documents created directly in PandaDoc link to people automatically when an email matches, but never link to deals, and there is no manual “attach existing document” option in Attio. The practical rule for the team: documents that belong to a deal get created from the deal, full stop.

With the rules respected, the day-to-day is simple: View documents from Quick actions or the record menu lists each document with its live status, and the PandaDoc widget on deal and person record pages shows the most recent document’s status without opening anything. The answer to “has it been signed?” should be on the record, not in someone’s inbox.

Teams we work with typically start at 45 to 50 minutes per proposal and get to minutes once generation runs from the record they already manage work in.

Step 6: Wire the workflow trigger, then test and cut over

The workspace connection from Step 1 pays off here. The Document status changed trigger starts an Attio workflow when a document hits one of five statuses: completed, viewed, declined, sent, or voided. An optional template filter scopes it to one template, which is how you give contracts different automation than proposals. The trigger outputs the document’s ID and name, recipient emails, relevant dates, and the deal or custom object record it came from, so the workflow can act on the right record.

The canonical build is the one Attio documents: when a contract completes, update the deal stage. Add the obvious siblings: notify the owner when a proposal is viewed, open a task when one is declined. This is the integration’s writeback story, and it only exists if the API-key connection was made.

Then test with live data before rollout:

• Generate documents from five to ten real records, including at least one messy one: a long deal name, an unusual character in a company name, an empty optional attribute.
• Check every variable filled, the suggested recipients matched expectations on each record type, and the status flowed back to View documents and the widget.
• Fire each workflow trigger once for real by completing a test document, and confirm the deal stage or notification actually moved.
• Have one team member, not the admin who built it, run the flow end to end and note every point of hesitation.

Then roll out deliberately: short role-based training, a first-week target of every user sending at least one real document through the new flow, and a named date when the old route (Word, Google Docs, duplicated PDFs) is closed. Teams that run old and new in parallel indefinitely drift back to the old way, because habit always wins a tie. The full playbook for this stage is in our PandaDoc onboarding service.

The four ways PandaDoc Attio setups fail

Having rescued a fair number of stalled setups, the failure points are consistent:

1. The workspace connection never happened. Members connected, documents generate, and everyone assumes the integration is fully installed. Months later someone asks why document status cannot drive a workflow. The API-key connection was never made, so the trigger was never available.
2. Company records assumed in. The team’s data model centres on companies, nobody checked that companies support neither creating nor viewing documents, and the gap surfaces mid-rollout as “the integration is broken.” It is not broken; the system of record needed to be deals or a custom object from the start.
3. Mapped-but-empty attributes. The variables exist, the data does not, documents generate with blanks, and the team goes back to typing. Fix the attribute discipline on the pipeline or drop the variable.
4. Pricing pushed back outside the system. Because line items do not transfer, someone decides pricing belongs in a spreadsheet again, and every document inherits its errors. The catalog-in-PandaDoc pattern above exists so this gap does not become a regression.

If you recognise your own setup in that list, the repair is usually faster than the original build, because the workarounds show you exactly what is broken.

PandaDoc Attio integration FAQ

What PandaDoc plan do I need for the Attio integration?

A PandaDoc Business plan is required to connect Attio with PandaDoc. The app itself is available on all Attio plans. Check PandaDoc’s current pricing page before committing, as plan packaging changes.

Why can’t I create documents from company records in Attio?

The integration supports person, deal, and custom object records only; companies support neither creating nor viewing documents. If your document flow is company-centric, generate from the linked deal instead, or build a custom object as the system of record with a relationship attribute feeding suggested recipients.

Why are my document variables coming through blank?

Three usual causes, in order: the attribute is empty on the record you generated from; the attribute type does not map (multi-value record and relationship attributes, for example, cannot be variables); or the attribute was created after the document, since only attributes that existed at creation are available. Also note auto-mapped Attio values overwrite existing PandaDoc field data, not the other way round.

Can Attio line items flow into PandaDoc pricing tables?

No. The integration maps single attributes as variables; nothing transfers into pricing tables or quote builder blocks as line items. Build pricing in PandaDoc’s catalog and pricing tables, and feed headline numbers like the deal value from currency attributes as variables.

Does document status write back to Attio?

Yes, in two ways. Status is visible on the record through View documents and the PandaDoc widget. And the Document status changed workflow trigger can act on status (completed, viewed, declined, sent, voided), for example moving a deal stage when a contract completes. The trigger requires the admin-level workspace connection via API key, not just member connections.

Get the integration implemented properly

The app install gets you a connection. The PandaDoc Attio integration page covers what we build on top of it: attribute mapping that fills reliably, templates your team cannot break, a pricing catalog that closes the line-item gap, workflow triggers that move deals on their own, and a rollout the team sticks with. If your integration has been “set up” for months and documents are still assembled by hand, that gap is precisely what we fix.