Quip

Quip's API access is the simplest in this productivity category to set up — no OAuth app registration, no developer account approval process, no API key review. You generate a personal access token directly from your Quip profile settings in under a minute. In your browser, go to quip.com and log into your account. Click your profile picture or initials in the top-left corner of the Quip interface. Select 'Edit Profile' from the dropdown menu. In the Profile settings panel, scroll down to find the 'Developers' section (or look for an 'API Tokens' or 'Access Tokens' section — the exact label may vary by Quip plan). Click 'Get Personal Access Token'. Quip will generate a token and display it once. Copy it immediately and paste it into a secure password manager — you won't be able to see the full token again without generating a new one. This personal access token has no automatic expiry date. It's tied to your Quip account and has access to everything your account can access: all your private documents, shared folders you're a member of, and any Quip spaces your organization has granted you access to. If you're building for a team and want a shared service account (so the documents aren't owned by one individual), create a dedicated Quip account (e.g., 'operations@yourcompany.com') and generate the token from that account's profile. Also note your account's personal folder thread ID: navigate to your Quip private folder, look at the URL — it will contain a thread ID you can use to specify where new documents are created.

1{
2  "token_location": "quip.com → Profile → Edit Profile → Developers → Get Personal Access Token",
3  "token_format": "A long alphanumeric string (varies in length)",
4  "expiry": "No automatic expiry — revoke manually in the same settings panel if needed",
5  "personal_folder_url_example": "https://quip.com/BXNABAxxxxxx (the ID 'BXNABAxxxxxx' is your folder thread ID)"
6}

Set up the Quip API connector in Bubble with the personal access token as a Private Bearer header. Quip uses a non-standard base URL (`https://platform.quip.com/1`) — note the version number `/1` at the end, which is part of the base URL. In your Bubble app, go to the Plugins tab. Install the API Connector plugin if not already installed (Add plugins → search 'API Connector' → Install). Open API Connector and click 'Add another API'. Name it 'Quip'. Set the base URL to `https://platform.quip.com/1` — include the `/1` version path. All call paths will start after this base URL. Leave authentication type as 'None' — you'll add auth via a custom header. Click 'Add a shared header': - Key: `Authorization` - Value: `Bearer YOUR_ACCESS_TOKEN` (paste the full token you copied from Quip) - Check 'Private' — this keeps the token server-side, invisible to browser traffic Do NOT add a Content-Type header at the connector level — Quip requires different content types for different calls (no body for GET calls, form-encoded for document creation POST). You'll set Content-Type at the individual call level where needed. Click 'Save' on the connector.

1{
2  "connector_name": "Quip",
3  "base_url": "https://platform.quip.com/1",
4  "shared_headers": [
5    {
6      "key": "Authorization",
7      "value": "Bearer YOUR_TOKEN_HERE",
8      "private": true
9    }
10  ],
11  "note": "Do NOT set Content-Type at connector level — Quip uses form-encoded for POST /threads/new-document and JSON for other endpoints. Set per-call."
12}

Add two initial calls: one to verify your authentication is working correctly, and one to browse folder contents. Both use standard JSON responses — no special body type needed. First call — Verify Auth: Click 'Add another call' inside the Quip connector. Name it 'Get Current User'. Method: GET. Path: `/users/current`. No parameters needed. Click 'Initialize call'. You should see a JSON response with your Quip user ID (`id`), name, email address, and profile URL. This confirms your token and base URL are correct. Set 'Use as: Data (not a list)' since it returns a single object. If Initialize returns a 401 error: your token is incorrectly formatted or expired. Double-check you pasted the full token and it begins with `Bearer ` (with a space) in the Authorization header value. Second call — List Folder Contents: Add another call. Name it 'Get Folder'. Method: GET. Path: `/folders/<folderId>`. Add a path parameter: `folderId` (type: text, dynamic). During initialization, type your personal folder thread ID as the test value. Click Initialize. The response contains `folder` metadata and `children` — a list of child items, each with a `thread_id` and `is_folder` boolean. Important: `children` returns thread IDs only, not titles or document metadata. This is Quip's architectural choice — to get document names and dates, you need the batch thread fetch call (next step). Think of this call as 'get the IDs', and the next call as 'get the details for those IDs'.

1{
2  "call_verify_auth": {
3    "name": "Get Current User",
4    "method": "GET",
5    "path": "/users/current",
6    "sample_response": {
7      "id": "BXNABAxxxxxx",
8      "name": "Jane Founder",
9      "emails": ["jane@company.com"],
10      "profile_picture_url": "https://quip.com/..."
11    }
12  },
13  "call_get_folder": {
14    "name": "Get Folder",
15    "method": "GET",
16    "path": "/folders/<folderId>",
17    "dynamic_params": [
18      { "key": "folderId", "type": "path", "example": "BXNABAxxxxxx" }
19    ],
20    "sample_response": {
21      "folder": {
22        "id": "BXNABAxxxxxx",
23        "title": "Private",
24        "created_usec": 1620000000000000,
25        "updated_usec": 1720000000000000
26      },
27      "children": [
28        { "thread_id": "AABBCCxxxxxx", "is_folder": false },
29        { "thread_id": "DDEEFFxxxxxx", "is_folder": true }
30      ]
31    }
32  }
33}

Quip's architecture separates folder structure (which contains only IDs) from thread metadata (which contains titles, dates, and content URLs). To display document titles in your Bubble repeating group, you need a batch thread fetch call that takes a list of thread IDs and returns full metadata for each. Add a new call. Name it 'Batch Get Threads'. Method: POST. Path: `/threads`. Set body type to 'Form (application/x-www-form-urlencoded)' — this call uses form encoding. Add a form parameter: `ids` (type: text, dynamic). The value should be a comma-separated list of thread IDs from the folder's children array. For initialization: in the `ids` test value, type two real thread IDs from your folder separated by a comma (e.g., `AABBCCxxxxxx,DDEEFFxxxxxx`). Click Initialize. Quip returns a JSON object where each key is a thread ID and the value is the thread metadata object containing: `title`, `link`, `created_usec`, `updated_usec`, `author_id`, `type` (document, spreadsheet, etc.). Note: Bubble API Connector handles this keyed-object response differently from arrays. The detected fields will include the first thread ID as a key name — this is intentional. In your Bubble workflows, you'll access individual threads by their key. For a repeating group, you may need to parse the response in a workflow and store results in a custom data type if the keyed structure is difficult to bind directly. The practical approach: after fetching the batch response in a workflow, use a 'Set state' action to store individual title + link pairs in a Bubble custom state list (a list of a custom data type with fields: threadId, title, link, updatedDate).

1{
2  "call_name": "Batch Get Threads",
3  "method": "POST",
4  "path": "/threads",
5  "body_type": "Form (application/x-www-form-urlencoded)",
6  "form_params": [
7    {
8      "key": "ids",
9      "value": "<comma_separated_thread_ids>",
10      "dynamic": true
11    }
12  ],
13  "sample_response": {
14    "AABBCCxxxxxx": {
15      "thread": {
16        "id": "AABBCCxxxxxx",
17        "title": "Acme Corp Account Plan",
18        "link": "https://quip.com/AABBCCxxxxxx",
19        "type": "document",
20        "created_usec": 1720000000000000,
21        "updated_usec": 1720500000000000
22      }
23    },
24    "DDEEFFxxxxxx": {
25      "thread": {
26        "id": "DDEEFFxxxxxx",
27        "title": "Q3 Pipeline Review",
28        "link": "https://quip.com/DDEEFFxxxxxx",
29        "type": "spreadsheet"
30      }
31    }
32  },
33  "note_for_bubble": "Response is a keyed object (thread ID as key), not an array. Store results in a Bubble custom data type list via workflow."
34}

This is the core integration step for the account plan generator use case, and the one most likely to fail if misconfigured. Quip's document creation endpoint requires form-encoded body — NOT JSON. If you configure it as a JSON body, Quip returns 400 Bad Request with no helpful error message. Add a new call. Name it 'Create Document'. Method: POST. Path: `/threads/new-document`. Set the body type to 'Form (application/x-www-form-urlencoded)' — click the body type dropdown and select 'Form' (not 'JSON'). Add the following form parameters: - `title` (dynamic, text): the document title — e.g., 'Acme Corp Account Plan — 2026-07-10' - `content` (dynamic, text): the document body content — supports HTML formatting (Quip parses HTML in document content) - `member_ids` (dynamic, text, optional): a comma-separated list of folder thread IDs or user IDs to share the document with - `type` (optional, default 'document'): can be 'document' or 'spreadsheet' For initialization: provide test values for title (`Test Account Plan`) and content (`<h1>Test Plan</h1><p>Discovery notes here.</p>`). Click Initialize. A successful response returns a thread object containing `id`, `title`, `link` (the URL to open the document in Quip's web client), `created_usec`, and `author_id`. In Bubble workflows, trigger this call on form submission. Map the Bubble input values to the form parameters. On success, store the returned `thread_id` and `thread_link` in your Bubble data type record (e.g., in the Client data type's 'quip_document_url' field). Show a confirmation popup with a link to the newly created Quip document.

1{
2  "call_name": "Create Document",
3  "method": "POST",
4  "path": "/threads/new-document",
5  "body_type": "Form (application/x-www-form-urlencoded)",
6  "form_params": [
7    { "key": "title", "value": "<documentTitle>", "dynamic": true },
8    { "key": "content", "value": "<documentContent>", "dynamic": true, "note": "HTML supported" },
9    { "key": "member_ids", "value": "<folderOrUserIds>", "dynamic": true, "optional": true }
10  ],
11  "sample_success_response": {
12    "thread": {
13      "id": "GGHHIIxxxxxx",
14      "title": "Acme Corp Account Plan — 2026-07-10",
15      "link": "https://quip.com/GGHHIIxxxxxx",
16      "created_usec": 1752134400000000,
17      "author_id": "BXNABAxxxxxx"
18    }
19  },
20  "common_400_cause": "body_type set to JSON instead of Form"
21}

Assemble the Bubble form that auto-creates Quip documents, and optionally combine it with Salesforce data for a full CRM workflow. On a Bubble page, add a Group or Popup containing your discovery form. Add Input elements for: Company Name (text), Primary Challenge (long text — use a Multiline Input), Proposed Solution (multiline), Timeline (dropdown: '1-3 months', '3-6 months', '6-12 months'), Key Stakeholders (text). Add a Button: 'Create Account Plan'. Add a workflow: When 'Create Account Plan' button is clicked → Step 1: Create a custom state 'planContent' with a text value built from the form inputs using Bubble's text composition (combine with `<h1>`, `<h2>`, `<p>` tags). Example: `'<h1>' + Company Name input value + ' — Account Plan</h1><h2>Primary Challenge</h2><p>' + Challenge input value + '</p><h2>Proposed Solution</h2><p>' + Solution input value + '</p>'`. Step 2: Plugins → Quip - Create Document (title = Company Name + ' Account Plan — ' + Current date formatted as YYYY-MM-DD; content = planContent custom state; member_ids = your designated folder thread ID). Step 3: Make changes to the relevant Bubble Client record — set its 'quip_account_plan_url' field to 'Result of step 2's thread link'. Step 4: Show a popup with the message 'Account plan created!' and a Link element pointing to 'Result of step 2's thread link'. For Salesforce integration: if your Bubble app also has Salesforce data via Bubble's native Salesforce plugin, add a Step 5 that updates the Salesforce Account record's custom field with the Quip document URL. RapidDev's team has built three-way Salesforce + Bubble + Quip integrations — if you need help structuring this workflow, book a free scoping call at rapidevelopers.com/contact.

1{
2  "form_workflow": {
3    "trigger": "'Create Account Plan' button is clicked",
4    "step_1": {
5      "action": "Set state: planContent",
6      "value": "'<h1>' + CompanyName input's value + ' — Account Plan</h1><h2>Primary Challenge</h2><p>' + Challenge input's value + '</p><h2>Proposed Solution</h2><p>' + Solution input's value + '</p><h2>Timeline</h2><p>' + Timeline dropdown's value + '</p>'"
7    },
8    "step_2": {
9      "action": "Plugins → Quip - Create Document",
10      "params": {
11        "title": "CompanyName input's value + ' Account Plan — ' + Current date/time formatted as YYYY-MM-DD",
12        "content": "page's planContent custom state",
13        "member_ids": "YOUR_FOLDER_THREAD_ID"
14      }
15    },
16    "step_3": {
17      "action": "Make changes to Client record",
18      "field": "quip_account_plan_url = Result of step 2's thread link"
19    },
20    "step_4": {
21      "action": "Show popup",
22      "content": "Success message + Link element pointing to Result of step 2's thread link"
23    }
24  }
25}