How to Integrate Retool with Quip

To access Quip's API, generate a personal access token from your Quip account. Log into Quip and click your profile picture in the top left. Select 'Edit Profile' from the dropdown. On your profile page, scroll down to find the 'Developers' section and click 'Get Personal Access Token'. Quip generates a token immediately and displays it once — copy it now and store it securely. This token gives full API access to your Quip account including all documents you can see. Now go to the Resources tab in your Retool instance and click Add Resource. Select REST API from the resource type list. Name the resource 'Quip API'. In the Base URL field, enter https://platform.quip.com/1. This is Quip's API v1 base URL — all endpoint paths are appended to this. Do not include a trailing slash. For authentication, select Bearer Token from the Authentication dropdown. In the Token field, enter your Quip personal access token. For better security, store your token as a Retool configuration variable first: go to Settings → Configuration Variables, create a variable named QUIP_ACCESS_TOKEN, mark it as Secret, and use {{ retoolContext.configVars.QUIP_ACCESS_TOKEN }} in the Token field instead of the raw value. Add a Content-Type header: key = Content-Type, value = application/json. Click Save Changes.

Quip's API organizes content around threads (documents, spreadsheets) and folders. The folder endpoint returns the folder structure and lists contained threads. The thread endpoint returns individual document content and metadata. Create a query named getFolderContents and select the Quip API resource. Set Method to GET. In the Path field, enter /folders/{{ textInput_folderId.value || 'PRIVATE' }}. The folder ID comes from the Quip URL when viewing a folder. 'PRIVATE' is a special keyword that returns your personal folder tree. The folder response includes a folder object with children — each child has a thread_id (for documents) or folder_id (for nested folders). Quip returns IDs rather than full objects, so you need a second query to fetch thread details. Create a query named getThread (GET, /threads/{{ textInput_threadId.value }}) for fetching individual document metadata and content. This returns the thread object with fields including title, link, author_id, created_usec, updated_usec, and thread_class (document, spreadsheet, or chat). For listing multiple threads at once, Quip supports a batch endpoint: POST /threads to get multiple threads by their IDs in a single request. This is more efficient than making individual GET requests for each thread in a folder. Create a JavaScript query named buildDocumentList that combines the folder contents with batch thread fetching to build a complete listing: Bind the result to a Table component with columns for title, thread_class, last modified date, and a link to open the document in Quip.

1// JavaScript transformer — format Quip thread list from folder contents
2// 'data' is the response from the batch threads endpoint
3const threads = data || {};
4return Object.values(threads).map(thread => ({
5  id: thread.thread?.id || '',
6  title: thread.thread?.title || 'Untitled',
7  type: thread.thread?.thread_class || 'document',
8  link: thread.thread?.link || '',
9  author_id: thread.thread?.author_id || 'N/A',
10  created: thread.thread?.created_usec
11    ? new Date(thread.thread.created_usec / 1000).toLocaleDateString('en-US', {
12        year: 'numeric', month: 'short', day: 'numeric'
13      })
14    : 'N/A',
15  last_modified: thread.thread?.updated_usec
16    ? new Date(thread.thread.updated_usec / 1000).toLocaleDateString('en-US', {
17        year: 'numeric', month: 'short', day: 'numeric'
18      })
19    : 'N/A',
20  is_stale: thread.thread?.updated_usec
21    ? (Date.now() - thread.thread.updated_usec / 1000) > 30 * 24 * 60 * 60 * 1000
22    : false
23}));

Build document creation functionality that allows your team to generate new Quip documents (account plans, meeting notes, status reports) directly from Retool. Add a Form section to your Retool app with these input components: - TextInput named input_title for the document title - TextArea named input_content for the document body text - Select named select_folder for choosing the destination folder Create a query named createDocument. Set Method to POST. Path = /threads/new-document. Set Body type to Form (not JSON — Quip's document creation uses form-encoded data). Add form body parameters: - key: title, value: {{ input_title.value }} - key: content, value: {{ input_content.value }} (HTML content is supported) - key: member_ids, value: {{ select_folder.value }} (the folder ID to add the document to) For richer document content, Quip accepts HTML in the content field. Use a TextArea or a Code editor component in Retool for users to input formatted content, or pre-format the content in your query body using template literals. Add a 'Create Document' button that triggers createDocument. In the On Success event handler, show a notification 'Document created successfully', and add a Link component that opens the created document: {{ createDocument.data.thread.link }}. Trigger getFolderContents to refresh the document list after creation so the new document appears immediately. For Salesforce-integrated workflows where documents need to link back to Salesforce records, add a second step in the event handler that updates the Salesforce record via your Salesforce resource with the new Quip thread URL.

1// Quip document creation — form-encoded body
2// Method: POST
3// Path: /threads/new-document
4// Body type: x-www-form-urlencoded
5
6// Parameters to send:
7title={{ input_title.value }}
8content=<h1>{{ input_title.value }}</h1><h2>Overview</h2><p>{{ input_overview.value }}</p><h2>Next Steps</h2><p>{{ input_next_steps.value }}</p>
9member_ids={{ select_folder.value }}
10
11// After creation, the response includes:
12// thread.id — the new document's thread ID
13// thread.link — the shareable URL to open in Quip
14// thread.title — confirms the title was saved

Since Quip is a Salesforce product, the most powerful Retool integration combines Quip document management with Salesforce CRM data. Add your Salesforce connection as a second resource in the same Retool app. Create a Salesforce query named getOpenOpportunities. If using the native Salesforce connector: Action = SOQL Query, Query = SELECT Id, Name, Account.Name, Amount, CloseDate, StageName, Quip_Document_URL__c FROM Opportunity WHERE StageName NOT IN ('Closed Won', 'Closed Lost') ORDER BY CloseDate ASC LIMIT 50. The Quip_Document_URL__c field is a custom field where your team stores the associated Quip document link (adjust the API name to match your org's field). Bind getOpenOpportunities to a Table. When a rep selects an opportunity, check whether a Quip document exists: if Quip_Document_URL__c is populated, show a 'View Account Plan' button linking to the document. If empty, show a 'Create Account Plan' button that triggers the document creation workflow. For 'Create Account Plan': trigger the createDocument query with a pre-formatted template that includes the opportunity name, account name, and close date. On success, update the Salesforce opportunity to store the new Quip thread URL in Quip_Document_URL__c using a PATCH/update Salesforce query. For viewing existing documents, add a Quip document preview by fetching the thread content (GET /threads/{id}/html) and rendering it in a Retool Custom Component or displaying a summary of the document sections. RapidDev's team can help design more complex Quip-Salesforce workflows, such as automatically generating account plans for all new opportunities above a certain ARR threshold using Retool Workflows triggered by Salesforce record creation events.

1// SOQL query — get opportunities with Quip document status
2// Use in Salesforce resource query, Action: SOQL Query
3SELECT
4  Id,
5  Name,
6  Account.Name,
7  Amount,
8  CloseDate,
9  StageName,
10  OwnerId,
11  Owner.Name,
12  Quip_Document_URL__c
13FROM Opportunity
14WHERE StageName NOT IN ('Closed Won', 'Closed Lost')
15  AND Amount >= 10000
16ORDER BY CloseDate ASC
17LIMIT 100

Add search functionality to let users find Quip documents by keyword, author, or date range without knowing the exact folder structure. Create a query named searchThreads. Set Method to GET. Path = /threads/search. Add URL parameters: - key = query, value = {{ textInput_search.value }} - key = count, value = 20 Quip's search endpoint returns matching threads ordered by relevance. Bind results to a Table showing title, thread type, and last modified date. Create a query named getUserProfile (GET, /users/{{ userId }}) to resolve author IDs returned by thread queries into human-readable names. Build a user ID-to-name lookup by first fetching /users/current and then resolving individual IDs as needed. For document organization, create a query named addMember to add a user or folder to an existing thread's member list: - Method: POST - Path: /threads/{{ table_threads.selectedRow.id }}/add-members - Body: Form encoded, key = member_ids, value = {{ textInput_member_email.value }} Create a query named exportThread to get a thread's full HTML content for export or preview: - Method: GET - Path: /threads/{{ table_threads.selectedRow.id }}/html Display the HTML content in a Retool HTML display component or a Custom Component for a document preview panel.

1// JavaScript transformer — format Quip search results
2const results = data || {};
3// Quip search returns an object keyed by thread ID
4return Object.entries(results).map(([id, thread]) => {
5  const t = thread.thread || {};
6  return {
7    id,
8    title: t.title || 'Untitled',
9    type: t.thread_class || 'document',
10    link: t.link || '',
11    created: t.created_usec
12      ? new Date(t.created_usec / 1000).toLocaleDateString('en-US')
13      : 'N/A',
14    last_modified: t.updated_usec
15      ? new Date(t.updated_usec / 1000).toLocaleDateString('en-US')
16      : 'N/A',
17    // Days since last edit
18    days_since_update: t.updated_usec
19      ? Math.floor((Date.now() - t.updated_usec / 1000) / (1000 * 60 * 60 * 24))
20      : null
21  };
22}).sort((a, b) => (a.days_since_update || 0) - (b.days_since_update || 0));