How to Integrate Replit with Quip

Quip provides two authentication options: a personal access token (simplest, best for server-side scripts you run yourself) and OAuth 2.0 (for applications where users authorize access to their own Quip accounts). For most Replit automation use cases — where you are automating your own Quip workspace — the personal access token is the right choice. To obtain one, go to quip.com/dev/token and click 'Get Personal Access Token'. The token will be displayed once — copy it immediately as you cannot retrieve it again (only regenerate a new one). This token grants full API access to your Quip account, so treat it as sensitive. If you need to access multiple users' Quip accounts (for a multi-tenant app), you will need to implement the OAuth 2.0 flow instead — register your app at quip.com/api/app to get a client ID and secret. For most single-account automations, the personal token is all you need. The Quip API base URL is https://platform.quip.com/1. All API calls use this token in an Authorization header as 'Bearer YOUR_TOKEN'. Store it in Replit Secrets as QUIP_ACCESS_TOKEN immediately after copying.

1# Python — verify Quip connection (verify.py)
2import requests
3import os
4
5ACCESS_TOKEN = os.environ['QUIP_ACCESS_TOKEN']
6headers = {'Authorization': f'Bearer {ACCESS_TOKEN}'}
7
8response = requests.get('https://platform.quip.com/1/users/current', headers=headers)
9if response.status_code == 200:
10    user = response.json()
11    print(f'Connected as: {user.get("name")} ({user.get("id")})')
12    print(f'Email: {user.get("emails", ["unknown"])[0]}')
13else:
14    print(f'Connection failed: {response.status_code}')
15    print(response.text)

Open the Replit Secrets panel (lock icon 🔒 in the sidebar). Add QUIP_ACCESS_TOKEN with the personal token you obtained. If you will be creating documents in a specific Quip folder, also add QUIP_FOLDER_ID (the folder ID where documents should be created). To find a folder ID, navigate to the folder in Quip's web UI and copy the alphanumeric ID from the URL — the URL format is quip.com/Q/FOLDER_ID when viewing a folder. If you plan to work across multiple folders (e.g., separate folders per team or client), store each as a named secret like QUIP_FOLDER_SALES, QUIP_FOLDER_ENGINEERING. Replit Secrets are AES-256 encrypted and injected as environment variables at runtime. The Quip personal token in particular grants full access to your account's documents, folders, and threads — it should never appear in code, git history, or deployment logs. Install required packages: for Node.js run npm install express axios; for Python add requests and flask to requirements.txt.

1// Node.js — verify all Quip secrets (check-secrets.js)
2const required = ['QUIP_ACCESS_TOKEN'];
3const optional = ['QUIP_FOLDER_ID'];
4
5for (const key of required) {
6  const val = process.env[key];
7  if (!val) {
8    console.error(`MISSING REQUIRED: ${key} — add it via Replit Secrets (lock icon 🔒)`);
9    process.exit(1);
10  }
11  console.log(`OK: ${key} (${val.length} chars)`);
12}
13
14for (const key of optional) {
15  const val = process.env[key];
16  console.log(val ? `OK (optional): ${key}` : `INFO: ${key} not set — will use default folder`);
17}
18
19console.log('Quip secrets configured correctly.');

Creating a document in Quip is a POST request to /1/threads/new-document. The request body includes the title, content (as HTML), and optionally the member IDs to share the document with and the folder ID to place it in. Quip supports a subset of HTML for document content — headings (h1-h3), paragraphs, bullet lists (ul/li), numbered lists (ol/li), bold (b/strong), italic (i/em), links (a href), and horizontal rules (hr). More complex HTML is stripped. The response includes the thread object with the thread ID (which you will use for subsequent operations like appending content or posting messages), the thread URL for sharing, and the document title. To append content to an existing document, use PUT /1/threads/{threadId}/append-content with an HTML content body. This adds content at the end of the document rather than replacing it, which is useful for log-style documents that grow over time (daily standup notes, weekly status updates, etc.). Build a reusable document creation function and a separate append function that your application logic calls.

1// Node.js — create and update Quip documents (quip-docs.js)
2const axios = require('axios');
3const qs = require('querystring');
4
5const BASE_URL = 'https://platform.quip.com/1';
6const ACCESS_TOKEN = process.env.QUIP_ACCESS_TOKEN;
7const FOLDER_ID = process.env.QUIP_FOLDER_ID;
8
9const headers = {
10  Authorization: `Bearer ${ACCESS_TOKEN}`,
11  'Content-Type': 'application/x-www-form-urlencoded'
12};
13
14async function createDocument(title, htmlContent) {
15  const body = qs.stringify({
16    title,
17    content: htmlContent,
18    format: 'html',
19    ...(FOLDER_ID && { member_ids: FOLDER_ID })
20  });
21  const res = await axios.post(`${BASE_URL}/threads/new-document`, body, { headers });
22  return res.data.thread;
23}
24
25async function appendToDocument(threadId, htmlContent) {
26  const body = qs.stringify({ content: htmlContent, format: 'html' });
27  const res = await axios.post(`${BASE_URL}/threads/${threadId}/append-content`, body, { headers });
28  return res.data.thread;
29}
30
31(async () => {
32  const content = `
33    <h1>Weekly Status Report — Week of 2026-03-30</h1>
34    <h2>Engineering</h2>
35    <ul><li>Completed OAuth integration</li><li>Deployed Replit webhook server</li></ul>
36    <h2>Sales</h2>
37    <ul><li>Closed 3 new accounts</li><li>Pipeline review scheduled</li></ul>
38  `;
39  const doc = await createDocument('Weekly Status 2026-W13', content);
40  console.log(`Document created: ${doc.title}`);
41  console.log(`URL: ${doc.link}`);
42  console.log(`Thread ID: ${doc.id}`);
43})();

Every Quip document has a built-in thread (conversation) where team members can post messages and @mention colleagues. From your Replit backend, you can automatically post messages to document threads to notify the team of updates, request input, or log automated actions. The endpoint is POST /1/messages/new. The request body includes the thread_id of the target document, the content (as HTML or plain text), and optionally the author_id if you are posting on behalf of a specific user. @mentions are formatted as special HTML elements: <quip-user id='USER_ID'/> in the message content. To get user IDs, call GET /1/users/current for your own ID or GET /1/users/{userId} for others, or search by email via GET /1/users/get-or-create?emails=user@example.com. Build a notification function that posts a standardized message to a specified thread and include it in your document creation workflow so every new document automatically gets a kickoff message. This creates a natural audit trail of when documents were created and by which automation.

1# Python — post messages to a Quip thread (post_message.py)
2import requests
3import os
4from urllib.parse import urlencode
5
6ACCESS_TOKEN = os.environ['QUIP_ACCESS_TOKEN']
7BASE_URL = 'https://platform.quip.com/1'
8
9headers = {
10    'Authorization': f'Bearer {ACCESS_TOKEN}',
11    'Content-Type': 'application/x-www-form-urlencoded'
12}
13
14def post_message(thread_id, message_html):
15    """Post a message to a Quip document thread."""
16    data = urlencode({'thread_id': thread_id, 'content': message_html, 'format': 'html'})
17    response = requests.post(f'{BASE_URL}/messages/new', data=data, headers=headers)
18    if response.status_code == 200:
19        msg = response.json()
20        print(f'Message posted: {msg.get("id")}')
21        return msg
22    else:
23        print(f'Error {response.status_code}: {response.text}')
24        return None
25
26def get_current_user_id():
27    response = requests.get(f'{BASE_URL}/users/current', headers=headers)
28    return response.json().get('id') if response.status_code == 200 else None
29
30# Example: post a document kickoff message
31THREAD_ID = 'your-thread-id-here'  # From the createDocument response
32post_message(
33    THREAD_ID,
34    '<p><strong>Automated:</strong> This document was created by the Replit status report bot. '
35    'Please fill in your team updates by EOD Wednesday.</p>'
36)