Automation API (Current)

License: Proprietary

Welcome to the documentation for the Automation API. This documentation describes the functionality available only in the current versions of API methods. You can also review the documentation for all API methods for information about both current and deprecated API methods.

Summary

The Quip Automation API provides read/write access to Quip, enabling you to automate processes and integrate Quip with other products you or your company uses.

The Automation API is REST-based. Responses are JSON, and errors are reported via standard HTTP codes in addition to JSON-formatted error information in the HTTP response bodies of relevant requests. We use OAuth 2 for authentication and authorization.

Core Concepts

Quip integrates documents and messages into a single unit that we call a thread. Most of the operations in the Quip Automation API operate on threads. Threads can simply be a list of messages, i.e., a chat thread, or they may have a document in addition to a list of messages. Each thread has a permanent 11 character id and a similar 12 character URL suffix that can be expired by the user. Apps receiving URLs should convert them to permanent ids using Get Thread before being used.

Quip documents are broken down into smaller units we call sections. Every paragraph in a document is a separate section, as is every item in a list or cell in a table. The Quip Automation API outputs documents as HTML for convenience, and the elements in the HTML have id attributes specifying their internal section ID. When you want to perform advanced transforms on a document, like modifying a checklist, you will need to use the section IDs. The official Python library contains a number of examples of parsing the HTML to get section IDs and using that data for edit operations.

Quip folders are not traditional file system folders. Quip folders are more like tags, i.e., a thread can be in multiple folders. When a thread is in a folder, it inherits the permissions of the folder, e.g., if you add a thread to a folder shared with three people, those three people will have access to the thread. Each user has special desktop and archive folders that cannot be deleted, shared, or renamed.

A Quip thread can be shared with a list of folders and individual users. A user can access the thread if they have access to any of the folders or if they are individually added to the thread.

We refer to the people in threads and folders as members throughout the API.

License Requirements

You can access Quip's APIs if your company uses any of these products:

  • A pre-existing Quip for Customer 360 product
  • Quip Plus
  • Quip Advanced
  • Lightning Experience in Enterprise, Professional, Performance, Unlimited, or Developer editions

Note: These Admin APIs are available only as add-on purchases: Events API and Governance API.

VPC Customers

If you're a Virtual Private Cloud (VPC) customer, you can call Quip's APIs using URIs in which you replace: quip.com with customername.onquip.com or quip-customername.com.

For example, if your company is Acme and the URI is https://platform.quip.com/1/threads/edit-document, as a VPC customer, use one of these URIs instead depending on your company's assigned VPC URL:

Rate Limits

Quip's APIs have rate limits to help ensure fair and reliable access to APIs for all of our customers.

When you call our APIs via integrations you build (including integrations using Process Builder and Flow), those calls are subject to our rate limits.

Per-user Rate Limits

The Automation API is rate limited by number of requests per minute per user - with defaults of:

  • 50 requests per minute per user
  • 750 requests per hour per user

API responses include a few custom headers to help developers implement backoffs in their code. These headers are:

  • X-Ratelimit-Limit: The number of requests per minute/hour the user can make
  • X-Ratelimit-Remaining: The number of requests remaining this user can make within the minute/hour. This number changes with each request
  • X-Ratelimit-Reset: The UTC timestamp for when the rate limit resets

Per-company Rate Limit

Quip's APIs are also subject to a per-company rate limit with a default of 600 requests per minute. The API responses include these custom headers to help developers implement backoffs in their code:

  • X-Company-RateLimit-Limit: The number of requests per minute that your company can make
  • X-Company-RateLimit-Remaining: The number of requests remaining for your company within the minute
  • X-Company-RateLimit-Reset: The UTC timestamp for when the rate limit resets
  • X-Company-Retry-After: The number of seconds after which your company can make API calls again

FAQs

Quip Developer FAQ

Which API should I use, the Automation API or the Admin API?

We recommend that you use the Automation API to automate user-level processes such as document copying and editing and to integrate Quip with your other systems. Use the Admin API for admin-level site-wide or security workflows such as activity monitoring or quarantining documents.

Which systems can integrate with Quip's APIs?

Quip's APIs integrate with Salesforce, Slack, Google Workspace, Github, Jira, Stripe, Dropbox, Box, Zendesk and more. You can connect nearly any application to Quip using our APIs, including your company's proprietary applications or systems. Browse our sample apps or download prebuilt apps on Salesforce AppExchange.

Can I create a non-human user account for my integrations?

In the Quip Admin Console, create a placeholder user (not associated with an employee) or bot user for your integrations. That way, when you deprovision an employee's user account, the integration isn't affected. Additionally, this allows for a more clear separation of duties between an employee and an integration user.

Is there a way for the API keys to be rotated every 90 days automatically or would this be a manual action?

Currently, there's no way for the API keys to change automatically. You can only create API keys manually.

Which API calls are included in rate limits?

All of your company's Admin and Automation API calls are counted in your rate limits, including calls you make via Process Builder and Flow. There are per-user and per-company rate limits for the Admin and Automation APIs.

Can we raise our rate limits?

If you need to call APIs more frequently than allowed by the Admin and Automation API rate limits, contact Quip Customer Support for help.

How do we monitor our API usage?

The responses in Quip's Admin and Automation APIs contain headers that provide information about your API usage.

Is there an API that can run reports on Quip engagement?

Use the Events API to get information about Quip engagement. You can then feed that information into your engagement monitoring systems.

What tools are available for Quip eDiscovery and eArchiving?

Consult our trusted partner for eDiscovery and eArchiving solutions at onna.com/quip.

How do I export my Quip data?

You can export Quip documents or spreadsheets to PDF using the Create Export PDF Request API method.

How do I export comments from a Quip document?

Use the Get Recent Messages API method to retrieve the 25 most-recent comments in a Quip document. You can then export the response of your API call to your other systems.

How do we deprovision users?

The Disable User v1.1 or v2.0 API method allows you to deactivate a user account.

Can we subscribe to news about changes to API documentation or feature updates?

Read the release notes to find out about new Quip developer features. Subscribe to the Salesforce Developer newsletter to get developer news, tips, and best practices. You can also follow these social media channels: SalesforceDevs Twitter feed, SalesforceDevs LinkedIn page, SalesforceDevs Facebook page.

More questions?

Ask other Quip developers on Salesforce Stack Exchange.

REST API Versioning FAQ

Why do API methods get versioned?

To improve the quality and performance of API methods, Quip periodically releases new versions and deprecates older versions. Examples of changes that sometimes require creating new versions are:

  • Renaming an API method; or
  • Adding a required input field; or
  • Removing or renaming an input field; or
  • Removing an output field.

How do I know which version of an API method I'm using?

Versions are identified in the path for each API method. Examples:

How will I know when an API method is deprecated?

We inform you in a release note at least one year before support for an API method ends. In addition, we update the reference documentation to identify the current and deprecated versions of an API method. Our REST APIs have two versions of reference documentation:

  • Current: Describes the functionality available only in the current versions of methods in a REST API.
  • All: Describes the functionality available in both current and deprecated versions of methods in a REST API.

What should I do when an API method is deprecated?

Update your integrations so that they point to the current version instead of a deprecated version before support for an API method ends. Example scenario:

As needed, for your integrations, you can download the OpenAPI Specification (OAS) files for current and all versions of each REST API.

Authentication

Overview

Authentication gives you access to the Quip Admin and Automation APIs. You can build integrations that call our APIs. To access Quip's APIs, first create an API key. Then get an access token using the API key as described in Get Access to Quip's APIs. You can create additional API keys for your other integrations with the applicable scopes needed for the features in a specific integration. You can also get a personal access token to test our APIs.

OAuth2

Use an OAuth2-compatible mechanism for authentication. Quip's approach follows RFC 6749.

Our API endpoints accept authentication tokens as described in RFC 6750. In most cases, this means that when you call our API endpoints, you can pass in an Authorization header with content "Bearer {{token}}". {{token}} is the value of an access token obtained by following the steps described in Get Access to Quip's APIs. The only endpoints that don't require an Authorization header are these Authentication endpoints: Token Endpoint, Authorization Endpoint, Revoke a Token.

This table lists the URLs for Quip's Authentication endpoints that you can call when you build your integrations. In addition, this table describes available scopes for the Automation API. See the Domain Authentication section and the reference documentation linked to in this table for information about using the authentication endpoints.

Security Scheme Type OAuth2
authorizationCode OAuth Flow
Authorization URL: https://platform.quip.com/1/oauth/login
Token URL: https://platform.quip.com/1/oauth/access_token
Refresh URL: https://platform.quip.com/1/oauth/access_token
Scopes:
  • USER_READ -

    Provides access to GET calls that read data.

  • USER_WRITE -

    Provides access to POST, DELETE, and PATCH calls that edit data.

  • USER_MANAGE -

    Provides access to API calls that perform actions requiring full access to a thread or folder. Examples: add or remove thread or folder access, lock or unlock a thread.

Note: Before building applications, you must select your required scopes when you create the API keys. And ensure that your application users have the correct access to the content they'll use in your applications. For example, if users need to edit a Quip document using your application, they must have edit access on that document.

Best Practices

Here are some recommended practices to follow to protect your Quip data and improve your user experience:

  • Limit the scopes in your API keys to the ones needed for the features in your integrations. For example, if you create an application whose users edit but don't manage content, don't include the USER_MANAGE scope in the API key for that application.
  • Tokens expire every 30 days. Use the Token Endpoint to refresh your tokens before their expiration. That way your users have uninterrupted access to your integrations.
  • Use Verify Token to see if a token is expired or revoked and find out which scopes apply to the token.
  • Revoke tokens for integrations that you're no longer using. Deleting a token in Postman (or your other chosen tool) doesn't revoke access. You can use the Admin Console to revoke an API key that you're no longer using (under Settings > Integrations > Action menu > Revoke).

Get Access to Quip's APIs


Personal Authentication Process

You can generate an access token that provides API access to your own, personal Quip account. This is useful for testing the API, automating tasks, or integrating with other services you use individually.

To generate a personal access token, visit this page: https://quip.com/dev/token

Whenever you generate a new token, all previous tokens are automatically invalidated.

Once you have a token, the easiest way to use it is via the Python Client Library, which makes most tasks a single line of code. All of the documentation below contains copy-and-paste Python code snippets to make it easier to get started.


OAuth Process


Prerequisites

To access to the Quip Admin and Automation APIs:

  • You must be an admin to create an API key.
  • In addition, for access to the Admin API, your admin has to add you to the Admin API Users list in the Admin Console (under Settings > Site Settings).

Note: These Admin APIs are available only as add-on purchases: Events API and Governance API.

Process Overview

To get access to the Quip Admin and Automation APIs, follow the process summarized in the diagram below. The process is described in detail in the Generate an OAuth Token section.


Generate an OAuth Token


1. Create an API Key

a. In the Quip Admin Console create an API key and select the scopes that you need for the features in your integration.

b. Copy the client ID and client secret so you can use them to get an access token.

Note:

  • You can create additional API keys for your integrations with only the applicable scopes needed for the features in the integrations.
  • You can create a maximum of 100 API keys for your company. We suggest that you keep this limit in mind when you create API keys for your integrations. You can see all the API keys your company has in the Quip Admin Console under Settings > Integrations.

2. Get an Access Token

Use your preferred tool such as Postman or SoapUI to get an access token. This example uses Postman:

a. Create a request in Postman.

b. Click the Authorization tab.

c. From the Type dropdown list, select Oauth 2.0.

d. In the Configure New Token section, fill in the fields as described here:

  • Token Name: Give the token a short, descriptive name. When you create additional tokens for your integrations, use a name that easily identifies the integration.
  • Callback URL: https://platform.quip.com
  • Authorize using browser: Leave the box unchecked.
  • Auth URL: https://platform.quip.com/1/oauth/login If you're a Virtual Private Cloud (VPC) customer, use one of these URLs instead, depending on your company's assigned VPC URL:
    • https://platform.<customername>.onquip.com/1/oauth/login or
    • https://platform.quip-<customername>.com/1/oauth/login
  • Access Token URL: https://platform.quip.com/1/oauth/access_token If you're a VPC customer, use one of these URLs instead, depending on your company's assigned VPC URL:
    • https://platform.<customername>.onquip.com/1/oauth/access_token or
    • https://platform.quip-<customername>.com/1/oauth/access_token
  • Client ID and Client Secret: Use the values that you copied from the API key in the Quip Admin Console.
  • Scope and State: Leave blank.
  • Client Authentication: Select Send client credentials in body.

e. Click Get New Access Token.



3. Get authorization from Quip

When prompted, use your admin email address and password to log into your Quip site and get an authorization token. This is required only the first time you get an access token.



4. Save the Token

In Postman, the token details are displayed. Click Use Token to save the provided token in your request and use it in your next API call.

Congratulations! You can now make Admin and Automation API calls. Follow these same instructions to get additional access tokens using API keys with the scopes required for the integrations you're building.

Note: Tokens expire every 30 days. Use the Token Endpoint to refresh your tokens before the 30-day expiration. That way your users have uninterrupted access to your integrations.

Next Steps

Now that you have access to our APIs, you can start building your integrations with Quip:

  • Browse through the reference documentation to see what you can build with our APIs.
  • Download our OpenAPI Specification (OAS) files to build your integrations.
  • Check out our sample apps.
  • Use a token associated with an API key together with domain authentication to build applications that integrate with Quip.

Questions? Ask the Quip developer community on Salesforce Stack Exchange.

Domain Authentication

Domain authentication is only available for Quip Enterprise administrators. To enable this for your company, contact us.

Domain authentication enables seamless integration for internal or pre-approved services at your company. Domain authentication is simply OAuth 2.0, but instead of end users individually approving access to each application, domain administrators pre-approve applications, and end users do not see additional authorization prompts during the OAuth authorization process.

To enable domain authentication for a third-party application:

  1. Create an OAuth 2.0 token for the application you want to integrate. You will typically create a separate token for each app you want to integrate and name it after the app, which enables easy revocation when your company is no longer using the service.
  2. Configure the application with the OAuth 2.0 authorization endpoint /oauth/login and the OAuth 2.0 token endpoint /oauth/access_token.
  3. When a member of your company uses the application to access Quip, the authorization redirects will happen automatically and will not ask for any additional approval.

Token Endpoint

After you have obtained a verification code or refresh token, you can exchange it for an access token via a POST request to this endpoint.

query Parameters
grant_type
required
string
Enum: "refresh_token" "authorization_code"

Either refresh_token or authorization_code.

client_id
required
string

The client ID you created for your application.

client_secret
required
string

The client secret you created for your application.

refresh_token
string

Required if grant_type is refresh_token.

code
string

Required if grant_type is authorization_code.

redirect_uri
string

Required if grant_type is authorization_code. Must match the redirect_uri supplied when requesting that authorization code.

Responses

Response samples

Content type
application/json
{
  • "access_token": "string",
  • "expires_in": 0,
  • "refresh_token": "string",
  • "scope": "string",
  • "token_type": "Bearer"
}

Authorization Endpoint

Redirect end users to this URL to get an OAuth 2.0 verification code, which you can exchange for an access token.

query Parameters
client_id
required
string

The client ID you created for your application.

client_secret
required
string

The client secret you created for your application.

redirect_uri
required
string
Example: redirect_uri=https://app.postman.com/oauth2/callback

The URL we should redirect back to with the verification code.

state
integer
Example: state=1234

If given, we include this argument in our redirect back to the redirect_uri. This is recommended to prevent a variety of security issues.

Responses

Response samples

Content type
application/json
{
  • "error": "string",
  • "error_code": 400,
  • "error_description": "string"
}

Revoke a Token

Revoke an access_token or a refresh_token.

query Parameters
client_id
required
string

The client ID you created for your application.

client_secret
required
string

The client secret you created for your application.

token
required
string

The token to revoke.

Responses

Response samples

Content type
application/json
{ }

Verify Token

Verifies the validity of the access_token in your header.

Responses

Response samples

Content type
application/json
{
  • "expires_in": 2425690,
  • "scope": "USER_MANAGE USER_WRITE USER_READ",
  • "token_type": "Bearer",
  • "client_id": "string"
}

Use cases

Edit a Document Use Cases

This document provides sample calls for some common use cases for the Edit a Document API method. In the examples below, we use the HTML format for the document content. You can mix and match the examples based on your business needs. See the Edit a Document reference documentation for more details including a sample response and information about the section_id, location, data-live-app-id, and document_range fields.

Note: If you're a Virtual Private Cloud (VPC) customer, see the Access Rules for more information about URIs to use for your API calls.

Add an Item at the End of a List

In this example, the section_id belongs to an item at the end (location 2) of a bulleted or numbered list or checklist.

POST https://platform.quip.com/1/threads/edit-document
Content-Type: application/json
Authorization: Bearer ABCSampleAccessToken

{
    "thread_id": "vTYlBwL8UT85",
    "format": "html",
    "content": "<li>Expert recommendations</li>",
    "section_id": "HcDACAX1iOK",
    "location": 2
}

Here's how the list looks before and after the API call:

Before the call After the call
  • Customer feedback
  • Usage metrics
  • Customer feedback
  • Usage metrics
  • Expert recommendations
  • Add a Paragraph before Other Content

    In this example, the section_id belongs to a paragraph before (location 3) which another paragraph is added.

    POST https://platform.quip.com/1/threads/edit-document
    Content-Type: application/json
    Authorization: Bearer ABCSampleAccessToken
    
    {
        "thread_id": "XerkArZUfekP",
        "format": "html",
        "content": "<p>Here's the account information for Acme Company:</p>",
        "section_id": "HcDACAwByNQ",
        "location": 3
    }
    

    Here's how the paragraph looks before and after the API call:

    Before the call After the call

    This customer is on the west coast.

    Here's the account information for Acme Company:

    This customer is on the west coast.

    Add Multiple Paragraphs after Other Content

    In this example, the section_id belongs to a paragraph after (location 2) which multiple paragraphs are added.

    POST https://platform.quip.com/1/threads/edit-document
    Content-Type: application/json
    Authorization: Bearer ABCSampleAccessToken
    
    {
        "thread_id": "vTYlBwL8UT85",
        "format": "html",
        "content": "<p>Customers like Acme want more options.</p><p>They like personalized service.</p>",
        "section_id": "HcDACAJZEQf",
        "location": 2
    }
    

    Here's how the content looks before and after the API call:

    Before the call After the call

    Here's the account information for Acme Company:

    This customer is on the west coast.

    Here's the account information for Acme Company:

    This customer is on the west coast.

    Customers like Acme want more options.

    They like personalized service.

    Edit a Paragraph/Replace Content

    In this example, the section_id belongs to the paragraph that's edited/replaced (location 4). You can edit/replace a document range instead, by passing 8 into the location field. See the Edit a Document reference documentation for more information about the document_range field.

    POST https://platform.quip.com/1/threads/edit-document
    Content-Type: application/json
    Authorization: Bearer ABCSampleAccessToken
    
    {
        "thread_id": "vTYlBwL8UT85",
        "format": "html",
        "content": "<p>Customers like Acme want more choices. They want a buffet experience.</p>",
        "section_id": "HcDABAJZEQf",
        "location": 4
    }
    

    Here's how the paragraph looks before and after the API call:

    Before the call After the call

    Customers like Acme want more options.

    Customers like Acme want more choices. They want a buffet experience.

    Delete a Document Range

    In this example, the document_range belongs to the content (heading title Topic 2 - Prerequisites and content under that heading and its subheadings) that's deleted (location 9).

    POST https://platform.quip.com/1/threads/edit-document
    Content-Type: application/json
    Authorization: Bearer ABCSampleAccessToken
    
    {
        "thread_id": "vTYlBwL8UT85",
        "location": 9,
        "document_range": "Topic 2  - Prerequisites"
    }
    

    Here's how the content looks before and after the API call:

    Before the call After the call

    Topic 1 - Introduction

    Content under Topic 1.

    Topic 2 - Prerequisites

    Content under Topic 2.

    Subtopic 2.1

    Content under Subtopic 2.1.

    Subtopic 2.1.1

    Content under Subtopic 2.1.1.

    Topic 3 - Acceptance Criteria

    Content under Topic 3.

    Topic 1 - Introduction

    Content under Topic 1.

    Topic 3 - Acceptance Criteria

    Content under Topic 3.

    Add, Edit, or Replace Content in or Around a Document Range

    In this example, the document_range belongs to the content (heading title Topic 4 - Important Notes and content under that heading and its subheadings) that's edited/replaced (location 8). You can add content before or after a document range by passing 7 (before) or 6 (after) into the location field. See the Edit a Document reference documentation for more information about the document_range field.

    POST https://platform.quip.com/1/threads/edit-document
    Content-Type: application/json
    Authorization: Bearer ABCSampleAccessToken
    
    {
        "thread_id": "vTYlBwL8UT85",
        "content": "<h2>Topic 4 - Considerations</h2><p>Our beta launch requires training users who speak multiple languages.</p>",
        "location": 8,
        "document_range": "Topic 4 - Important Notes"
    }
    

    Here's how the content looks before and after the API call:

    Before the call After the call

    Topic 4 - Important Notes

    Our beta launch requires user training.

    Topic 4 - Considerations

    Our beta launch requires training users who speak multiple languages.

    Add a Row to a Spreadsheet

    In this example, the section_id belongs to the row after (location 2) which another row is added.

    POST https://platform.quip.com/1/threads/edit-document
    Content-Type: application/json
    Authorization: Bearer ABCSampleAccessToken
    
    {
        "thread_id": "vTYlBwL8UT85",
        "format": "html",
        "content": "<tr><td>7</td><td>4,581</td><td>570</td></tr>",
        "section_id": "temp:C:dabc38cb2d6f789b426a14f31946",
        "location": 2
    }
    

    Here's how the spreadsheet looks before and after the API call:

    Before the call After the call
    Social media page likes in the past 3 months.
    83 75,914 35608
    94 2560 32569
    10 93387 9358
    Social media page likes in the past 3 months.
    83 75,914 35608
    94 2560 32569
    7 4,581 570
    10 93387 9358

    Edit a Cell in a Spreadsheet

    In this example, the section_id belongs to the cell that's edited/replaced (location 4).

    POST https://platform.quip.com/1/threads/edit-document
    Content-Type: application/json
    Authorization: Bearer ABCSampleAccessToken
    
    {
        "thread_id": "vTYlBwL8UT85",
        "format": "html",
        "content": "98",
        "section_id": "temp:s:HcDACAFj25V_temp:C:HcD5aa735cfd0dd58e3eee0e5ef0",
        "location": 4
    }
    

    The table below shows how the spreadsheet looks before and after the API call. In this example, the first cell in the spreadsheet is edited:

    Before the call After the call
    Social media page likes in the past 3 months.
    83 75,914 35608
    94 2560 32569
    7 4,581 570
    10 93387 9358
    Social media page likes in the past 3 months.
    98 75,914 35608
    94 2560 32569
    7 4,581 570
    10 93387 9358

    Add a Live App after Other Content

    The data-live-app-id mentioned in the content field applies to the type of live app that's added. In this example, the live app is a calendar and the section_id belongs to a paragraph after (location 2) which the calendar is added. This scenario adds a calendar containing two events scheduled for 4 October 2021 and 18 October 2021.

    POST https://platform.quip.com/1/threads/edit-document
    Content-Type: application/json
    Authorization: Bearer ABCSampleAccessToken
    
    {
        "thread_id": "vTYlBwL8UT85",
        "format": "html",
        "content": "<div data-live-app-id='AbNBjAC13no' \
                      data-live-app-payload='{\
                        \"events\":[\
                          {\
                            \"color\":\"GREEN\",\
                            \"dateRange\":{\"start\":\"2021-10-04\",\"end\":\"2021-10-04\"},\
                            \"content\":\"Kickoff Meeting\"\
                          },\
                          {\
                            \"color\":\"RED\",\
                            \"dateRange\":{\"start\":\"2021-10-18\",\"end\":\"2021-10-18\"},\
                            \"content\":\"Project Status\"\
                          }],\
                       \"displayMonth\":\"2021-10\"\
                      }'>\
                    </div>",
        "section_id": "HcDACAxeuYo",
        "location": 2
    }
    

    Here's how the content looks before and after the API call:

    Before the call After the call

    Let's start a customer satisfaction project.

    Edit Content in a Live App

    In this example, the section_id belongs to the cell in the live app that's edited/replaced (location 4). This scenario replaces the name of the calendar event "Kickoff Meeting" with "Project Kickoff".

    POST https://platform.quip.com/1/threads/edit-document
    Content-Type: application/json
    Authorization: Bearer ABCSampleAccessToken
    
    {
        "thread_id": "vTYlBwL8UT85",
        "format": "html",
        "content": "Project Kickoff",
        "section_id": "temp:C:HcDe5a29801dd43ce5b7d68c43f3",
        "location": 4
    }
    

    Here's how the content looks before and after the API call:

    Before the call After the call

    Summary of Additional Use Cases for Adding Live Apps

    Live App Type Summary of Use Case Sample HTML for Content Field
    Salesforce Record Add a Salesforce record
      <div data-live-app-id='XdJAjAN5Jbi' data-live-app-payload='{
        "record_id": "0013h00000C9tHJAAZ",
        "org_id": "00D3h000004XoQgEAK" }'>
      </div>
    
    Salesforce List Add a Salesforce record list
      <div data-live-app-id='QYUAjAGNxIo' data-live-app-payload='{
        "list_id": "00B3h000005lR7jEAE",
        "object_type": "Account",
        "org_id": "00D3h000004XoQgEAK" }'>
      </div>
    
    Salesforce List Add a Salesforce related list
      <div data-live-app-id='QYUAjAGNxIo' data-live-app-payload='{
        "record_id": "0013h00000Db6YAAAZ",
        "related_list_type": "Contact",
        "org_id": "00D3h000004XoQgEAK" }'>
      </div>
    
    Kanban Board Add a Kanban board with three columns:
    • To Do
    • In Progress
    • Completed
      <div data-live-app-id='KORAjAYHE50' data-live-app-payload='{
        "columns": [
            {
              "color": "RED",
              "headerContent": "To Do",
              "cards": [
                  {
                    "color": "RED",
                    "content": "First Card"
                  }
              ]
            },
            {
              "color": "YELLOW",
              "headerContent": "In Progress",
              "cards": [
                  {
                    "color": "YELLOW",
                    "content": "Second Card"
                  },
                  {
                    "color": "YELLOW",
                    "content": "New Card"
                  }
              ]
            },
            {
              "color": "BLUE",
              "headerContent": "Title",
              "cards": [
                  {
                    "color": "BLUE",
                    "content": ""
                  },
                  {
                    "color": "BLUE",
                    "content": "Third Card"
                  },
                  {
                    "color": "BLUE",
                    "content": "New Card"
                  }
              ]
            }
        ] }'>
      </div>
    
    Project Tracker Add a project tracker with five columns::
    • Project
    • Owner
    • Status
    • Deadline
    • Attachment
    <div data-live-app-id='JdGAjAc35Es' data-live-app-payload='{
      "columns": [
          {
            "content": "Project\\n",
            "type": "TEXT",
            "id": "0"
          },
          {
            "content": "Owner\\n",
            "type": "PERSON",
            "id": "1"
          },
          {
            "content": "Status\\n",
            "type": "STATUS",
            "id": "2",
            "options": [
                {
                  "label": "Upcoming",
                  "devName": "upcoming",
                  "color": "BLUE"
                },
                {
                  "label": "In Progress",
                  "devName": "in_progress",
                  "color": "YELLOW"
                },
                {
                  "label": "Complete",
                  "devName": "complete",
                  "color": "GREEN"
                }
            ]
          },
          {
            "content": "Deadline\\n",
            "type": "DATE",
            "id": "3"
          },
          {
            "content": "Attachment\\n",
            "type": "FILE",
            "id": "4"
          }
      ],
      "rows": [
          {
            "0": "Test\\n",
            "1": [
                "dFdAEAoma2c"
            ],
            "2": "upcoming",
            "3": 1605686400000,
            "4": null
          },
          {
            "0": "New Project\\n",
            "1": [],
            "2": null,
            "3": null,
            "4": null
          },
          {
            "0": "New Project\\n",
            "1": [],
            "2": null,
            "3": null,
            "4": null
          }
      ] }'>
    </div>
    

    See also

    Edit a Document reference documentation

    How Does Live Data Work in Quip?

    Live Apps Developer Guide

    Threads

    Add People to a Thread or Add a Thread to Folders

    Shares a Quip thread (document, spreadsheet, or chat) with specified people (members) at your company and adds the thread to folders. This supports information-sharing and collaboration within and across teams.

    Note:

    • You can add a maximum of 100 people to a thread per request and 2,500 people per thread across multiple requests.
    • You can add a thread to a maximum of 100 folders per request and 2,500 folders across multiple requests.

    See also: Share Documents and Folders

    Sample Calls

    In this example, four people are added to a thread with the ID e3fs7B2leat8. The users are added with these access levels:

    • 0: Full access
    • 1: Edit
    • 2: Comment
    • 3: View

    See the reference documentation for more information about the access levels.

    POST https://platform.quip.com/1/threads/add-members
    Content-Type: application/json
    Authorization: Bearer {{ABCSampleAccessToken}}
    
    {
        "thread_id": "e3fs7B2leat8",
        "member_ids_by_access_level”:
            [
                {"access_level": 0, "member_ids": ["ABC12341234"]},
                {"access_level": 1, "member_ids": ["DEF45456789"]},
                {"access_level": 2, "member_ids": ["LMN74856789"]},
                {"access_level": 3, "member_ids": ["XYZEF454599"]}
            ]
        }
    }
    

    In this example, two actions are taken on a thread with ID e3fs7B2leat8:

    1. Add it to a folder with ID abCsOFj2Ny3a.
    2. Add a member with user ID XYZJAEAck4vn to the thread.
    POST https://platform.quip.com/1/threads/add-members
    Content-Type: application/json
    Authorization: Bearer {{ABCSampleAccessToken}}
    {
        "thread_id": "e3fs7B2leat8",
        "member_ids": {"abCsOFj2Ny3a","XYZJAEAck4vn"}
    }
    
    Authorizations:
    OAuth2 (USER_MANAGE)
    header Parameters
    Content-Type
    string
    Example: application/x-www-form-urlencoded
    Request Body schema: application/x-www-form-urlencoded
    One of
    thread_id
    required
    string

    The ID or secret path of the thread to get information about. You can pass in either of these identifiers:

    member_ids
    required
    string

    A comma-separated list of folder IDs and user IDs. We add each user individually to the thread. We add the thread to each of the specified folder IDs. If you pass in a folder ID, use either of these folder identifiers:

    • Folder id: Identifier returned in the id field when you call the Get Folder API method.
    • Secret path: 12-character identifier that you can find in the URL of the folder. For example, in the URL "https://quip.com/N5aaOTih0VYy/TeamFolder", the secret path is N5aaOTih0VYy.

    The member_ids field is required if you didn't pass in a member_ids_by_access_level value. If you pass in a member_ids value instead of a member_ids_by_access_level, the access level defaults to Full Access.

    Note: For better performance, it’s recommended that you add no more than 1,000 items to a folder. There’s a maximum limit of 4,000 items per folder. Items include documents, spreadsheets, and subfolders. When your API call exceeds the suggested limit of 1,000 items, a warning message is returned in the API response. When your API call exceeds the maximum limit of 4,000 items, the request isn’t executed and the 400 error code is returned. For more information, see Folder Limits.

    Responses

    Response samples

    Content type
    application/json
    {
    • "thread": {
      },
    • "user_ids": [
      ],
    • "shared_folder_ids": [
      ],
    • "expanded_user_ids": [
      ],
    • "invited_user_emails": [ ],
    • "access_levels": {
      },
    • "html": "..."
    }

    Copy a Document or Template

    Makes a copy of a thread (Quip document, spreadsheet, or template). This API method allows you to easily reuse existing content, automatically add members to the thread, and add the thread to a folder. For example, after a predefined step is completed, you can make a copy of a template and fill it in with your specified content.

    Note: Quip has introduced a faster, more scalable version of this API method: Copy a Document or Template V2. You’re encouraged to modify your integrations to point to the latest versions of API methods. You can continue to access legacy versions of API methods until we announce when support for them ends.

    See also: Folders (Quip), REST API Versioning FAQ

    Sample Call

    In this example, a template with ID e3fs7B2leat8 is copied and the new document is filled in based on the data in the values field. The new thread is also added to a folder with ID N5aaOTih0VYy.

    POST https://platform.quip.com/1/threads/copy-document
    Content-Type: application/json
    Authorization: Bearer ABCSampleAccessToken
    
    {
        "thread_id": "e3fs7B2leat8",
        "title": "Customer Welcome",
        "folder_ids": "N5aaOTih0VYy",
        "values": "{
            "Customer": {"Age": 34, "Name": "Arnie"},
            "Greeting": "Hello"
        }",
        "copy_annotations": "false"
    }
    
    Authorizations:
    OAuth2 (USER_READUSER_WRITE)
    header Parameters
    Content-Type
    string
    Example: application/x-www-form-urlencoded
    Request Body schema: application/x-www-form-urlencoded
    thread_id
    required
    string

    The ID or secret path of the document to be copied:

    values
    string

    If you want to make a copy of a template and fill it in with your specified content, pass a JSON dictionary into this field. In the JSON dictionary, the keys must be strings and the values must be either strings or dictionaries. Keys can contain only the characters A-Z, a-z, 0-9, .(period) and _(underscore). For example:

    1. You have a document you want to copy that's a template containing these fields:

      Name = [[Customer.Name]]

      Age = [[Customer.Age]]

      [[Greeting]], [[Customer.Name]]!

    2. You pass this JSON dictionary into the values field:

      {"Customer": {"Age": 34, "Name": "Arnie"}, "Greeting": "Hello"}

    3. The copy of the document displays this content:

      Name = Arnie

      Age = 34

      Hello, Arnie!

    member_ids
    string

    Comma-separated list of user IDs of people who can access the new thread. If you don't pass in member_ids, only the user who called this API method has access to the new thread. There's a maximum limit of 100 member_ids per request. The default access level is Full Access, which means that added users can edit, comment on, and share the thread.

    folder_ids
    string

    Comma-separated list of identifiers of the folders you want to add the new thread to. If you don't pass in folder_ids, the new thread is added to the private folder of the user who called this API method. There's a maximum limit of 100 folder_ids per request. You can pass in either of these identifiers:

    • folder_id: Identifier returned in the id field when you call the Get Folder API method.
    • secret path: 12-character identifier that you can find in the URL of the folder. For example, in this URL: "https://quip.com/N5aaOTih0VYy/TeamFolder", the secret path is N5aaOTih0VYy.

    Note: For better performance, it’s recommended that you add no more than 1,000 items to a folder. There’s a maximum limit of 4,000 items per folder. Items include documents, spreadsheets, and subfolders. When your API call exceeds the suggested limit of 1,000 items, a warning message is returned in the API response. When your API call exceeds the maximum limit of 4,000 items, the request isn’t executed and the 400 error code is returned. For more information, see Folder Limits.

    title
    string

    The name of the new thread. The title is used as the first line of a document. We recommend that you pass in a title to clearly identify the new thread. If you don't pass in a title, the names of the original and new threads are the same.

    copy_annotations
    boolean
    Default: false

    Determines whether to copy comments in the original thread to the new thread. Possible values are:

    • true: Comments in the original thread are copied to the new thread.
    • false: Comments in the original thread aren't copied to the new thread.

    Responses

    Response samples

    Content type
    application/json
    {
    • "thread": {
      },
    • "user_ids": [
      ],
    • "shared_folder_ids": [
      ],
    • "expanded_user_ids": [
      ],
    • "invited_user_emails": [ ],
    • "access_levels": {
      },
    • "html": "..."
    }

    Copy a Document or Template V2

    Makes a copy of a Quip thread (document, spreadsheet, or template) and adds it to a folder. This API method allows you to easily reuse existing content. For example, after a predefined step is completed, copy a template and add your specified content. When you add the new thread to a folder, members can automatically access that thread. This supports information-sharing and collaboration within and across teams.

    Authorizations:
    OAuth2 (USER_READUSER_WRITE)
    path Parameters
    threadIdOrSecretPath
    required
    string [ 10 .. 32 ] characters

    The ID or secret path of the thread you want to modify. You can pass in either of these identifiers:

    Request Body schema: application/json
    title
    string

    The name of the new thread. The title is used as the first line of a document. We recommend that you pass in a title to clearly identify the new thread. If you don't pass in a title, the names of the original and new threads are the same.

    folder_id
    string

    Identifier of the folder you want to add the new thread to. If you don't pass in a folder_id, the new thread is added to the private folder of the user who called this API method. You can pass in either of these identifiers:

    • folder_id: Identifier returned in the id field when you call the Get Folder API method.
    • secret path: 12-character identifier that you can find in the URL of the folder. For example, in this URL: "https://quip.com/N5aaOTih0VYy/TeamFolder", the secret path is N5aaOTih0VYy.

    Note: Copy a Document or Template V2 is faster and more lightweight, so you can pass in only one folder ID. Copy a Document or Template V1 allows you to pass in multiple folder IDs.

    mail_merge_values
    object <= 1000 items

    If you want to make a copy of a template and fill it in with your specified content, pass a JSON dictionary into this field. In the JSON dictionary, the keys must be strings and the values must be either strings or dictionaries. Keys can contain only the characters A-Z, a-z, 0-9, .(period) and _(underscore). For example:

    • You have a document you want to copy that's a template containing these fields:

      Name = [[Customer.Name]]

      Age = [[Customer.Age]]

      [[Greeting]], [[Customer.Name]]!

    • You pass this JSON dictionary into the mail_merge_values field:

      {"Customer": {"Age": 34, "Name": "Arnie"}, "Greeting": "Hello"}

    • The copy of the document displays this content:

      Name = Arnie

      Age = 34

      Hello, Arnie!

    copy_annotations
    boolean
    Default: false

    Determines whether to copy comments in the original thread to the new thread. Possible values are:

    • true: Comments in the original thread are copied to the new thread.
    • false: Comments in the original thread aren't copied to the new thread.

    Responses

    Request samples

    Content type
    application/json
    {
    • "title": "❗️ very important cat pics ❗️",
    • "folder_id": "N5aaOTih0VYy",
    • "mail_merge_values": {
      },
    • "copy_annotations": false
    }

    Response samples

    Content type
    application/json
    {
    • "thread": {
      }
    }

    Delete a Thread

    Deletes the thread with the specified ID or secret.

    Authorizations:
    OAuth2 (USER_MANAGE)
    Request Body schema: application/x-www-form-urlencoded
    thread_id
    required
    string

    The ID or secret path of the thread to delete.

    wipeout
    boolean
    Default: false

    Whether to permanently delete the thread.

    Responses

    Response samples

    Content type
    application/json
    { }

    Edit a Document

    Modifies the content of a thread (Quip document or spreadsheet). This API method allows you to mix and match content from different sources and automatically add it to the same thread whenever new data becomes available. Quip users can then collaborate on the thread or make any other changes to it. Sample content: project status updates, meeting minutes, support cases, event registrations, approvals, survey results, or payments.

    Note

    • Live apps:
      • You can add only these types of live apps to a document: calendar, Salesforce record, Salesforce list, Kanban board, and project tracker.
    • Spreadsheets:
      • You can add a row or edit a cell in a spreadsheet embedded in a Quip document or a standalone Quip spreadsheet.
      • The number of columns that you pass into your API call must be less than or equal to the number of columns in the spreadsheet. Any extra columns you pass in aren't added.
      • Quip allows you to add a maximum of 100,000 cells to a spreadsheet. This means that you can add a maximum of 100,000 cells by calling this API method once or multiple times.
      • You can add a maximum of 1,000 rows with each API call.
      • For best performance, it's recommended that you limit the number of cells you add to a maximum of 30,000 for each spreadsheet.
    • Paragraphs:
      • You can't edit only a sentence in a paragraph. To edit a sentence, replace the paragraph it's in with new content.
      • Deleting a sentence in a paragraph deletes the whole paragraph.
    Authorizations:
    OAuth2 (USER_READUSER_WRITE)
    header Parameters
    Content-Type
    string
    Example: application/x-www-form-urlencoded
    Request Body schema: application/x-www-form-urlencoded
    thread_id
    required
    string

    The ID or secret path of the thread whose document you want to edit:

    format
    string
    Default: "html"
    Enum: "html" "markdown"

    Format of the content field. Required unless location is 5 (DELETE_SECTION).

    content
    string

    The HTML or Markdown for the content that you want to add. There's a maximum limit of 1 MB of content per request. You can add a live app by using a <div> tag containing these values in the content field:

    • data-live-app-id: ID of the type of live app you want to add. For your company, this ID is always the same for the same type of live app. For a live app currently in a document, you can find this ID in the html field returned by the Get Thread API method. For example, for a calendar, you can call the Get Thread API and the html field returns something similar to: data-live-app-id='AbNBjAC13no'. Pass 'AbNBjAC13no' into the content field every time you want to add a calendar to a document.
    • data-live-app-payload: A JSON string containing the data that you want to include in the live app.

    Note: We support most of the Markdown tags. The exceptions are described in the differences in the Python-Markdown implementation.

    section_id
    string

    The ID of the part of the thread where you want to add content. Each of these types of content has its own section_id: paragraph, list item, graphic, spreadsheet row, spreadsheet or live app cell, and live app. This field is required if the location is AFTER_SECTION, BEFORE_SECTION, REPLACE_SECTION, or DELETE_SECTION. Provide either a section_id or a document_range.

    • To find a section_id for all content except live app and spreadsheet data:

      • Select content in a thread and use this keyboard shortcut to copy a link to the content:
        • Windows: Ctrl + Shift + A
        • Mac: Command + Shift + A

      Paste the link into a text editor. The section_id is after the "#". For example, in this link: "https://quip.com/vXYlZwL8Ul35/CustomerFeedback#temp:C:UHA3342fed2be3f401fb513dc0cf", the section_id is temp:C:UHA3342fed2be3f401fb513dc0cf.

    • To find a section_id for all content including live app and spreadsheet data (for embedded and standalone spreadsheets):

      • Call the Get Thread API method and locate the ID for each HTML element in the html response field. For example:
        • In this HTML data: <div id='temp:C:HcD011418d4e25fe057d98300b99'>, the section_id for the corresponding live app is temp:C:HcD011418d4e25fe057d98300b99.
        • In this HTML data: <span id='temp:C:HcDe1a29801dd43ce5b7d68c43f3'>, the section_id for the corresponding live app cell is temp:C:HcDe1a29801dd43ce5b7d68c43f3.
        • In this HTML data: <span id='temp:s:HcDABA078jM_temp:C:HcD5aa735cfd0dd58e3eee0e5ef0'>, the section_id for the corresponding spreadsheet row is temp:s:HcDABA078jM.
        • In this HTML data: <span id='temp:s:HcDABA078jM_temp:C:HcD5aa735cfd0dd58e3eee0e5ef0'>, the section_id for the corresponding spreadsheet cell is temp:s:HcDABA078jM_temp:C:HcD5aa735cfd0dd58e3eee0e5ef0.
    document_range
    string

    The text of the heading of the document range you want to modify. The document range includes the heading and all subheadings below it up to the next heading of the same size or larger. Required if the location is AFTER_DOCUMENT_RANGE, BEFORE_DOCUMENT_RANGE, REPLACE_DOCUMENT_RANGE, or DELETE_DOCUMENT_RANGE. This parameter supports only documents and not spreadsheets. Provide either a section_id or a document_range. For example:

    • If you have content in this heading structure:
      • Topic 1
      • Topic 2
        • Subtopic 2.1
          • Subtopic 2.1.1
      • Topic 3
    • Then you delete document_range Topic 2:
      • All of the content from Topic 2 to Subtopic 2.1.1 and the text under those headings are deleted.
      • Only Topic 1 and Topic 3 are left in the document.
    location
    integer
    Default: 0
    Enum: 1 2 3 4 5 6 7 8 9

    Where we should insert the new content.

    • 0: APPEND - Add to the end of the document. This isn't supported for a standalone spreadsheet. To add a row at the end of a standalone spreadsheet, pass in the section_id of the last row in the spreadsheet and use location 2.
    • 1: PREPEND - Add to the beginning of the document. This isn't supported for a standalone spreadsheet. To add a row at the beginning of a standalone spreadsheet, pass in the section_id of the first row in the spreadsheet and use location 3.
    • 2: AFTER_SECTION - Insert after the section specified by section_id.
    • 3: BEFORE_SECTION - Insert before the section specified by section_id.
    • 4: REPLACE_SECTION - Delete the section specified by section_id and insert the new content at that location. This isn't supported for live apps. You can delete a live app and add another one with your chosen content.
    • 5: DELETE_SECTION - Delete the section specified by section_id (no content required).
    • 6: AFTER_DOCUMENT_RANGE - Insert after the document range specified by document_range.
    • 7: BEFORE_DOCUMENT_RANGE - Insert before the document range specified by document_range.
    • 8: REPLACE_DOCUMENT_RANGE - Delete the document range specified by document_range and insert the new content at that location.
    • 9: DELETE_DOCUMENT_RANGE - Delete the document range specified by document_range (no content required).

    Responses

    Response samples

    Content type
    application/json
    {
    • "thread": {
      },
    • "user_ids": [
      ],
    • "shared_folder_ids": [
      ],
    • "expanded_user_ids": [
      ],
    • "invited_user_emails": [ ],
    • "access_levels": {
      },
    • "html": "...",
    • "section_ids": [
      ]
    }

    Edit Thread Link Share Settings

    Changes share link settings on a thread.

    At least one of the following must be included in the request:

    • allow_external_access
    • mode
    • enable_request_access
    • show_conversation
    • show_edit_history
    • allow_messages
    • allow_comments
    Authorizations:
    OAuth2 (USER_MANAGE)
    Request Body schema: application/x-www-form-urlencoded
    thread_id
    required
    string

    The ID or secret path of the thread whose share link settings you want to edit.

    allow_external_access
    boolean

    Determines whether users outside your company can access the Quip thread. If true, users outside your company can access the Quip thread. If false, users outside your company can't access the Quip thread.

    mode
    string
    Enum: "edit" "view" "none"

    Indicates the access that users will have to the thread.

    enable_request_access
    boolean

    Allow users to request access to the document. When a user tries to access a document that they don't have access to, they are presented with a dialog informing them they do not have access to this document. If enable_request_access is true, this dialog will contain a "Request Access" button.

    show_conversation
    boolean

    Determines whether users can see the conversation pane in a Quip thread. If true, users can see the conversation pane. If false, users can't see the conversation pane.

    show_edit_history
    boolean

    Determines whether users can see a Quip thread's edit history in the conversation pane. If true, users can see the edit history. If false, users can't see the edit history.

    allow_messages
    boolean

    Determines whether users can add comments to an existing conversation in a Quip thread. If true, users can add comments to an existing conversation. If false, users can't add comments to an existing conversation.

    allow_comments
    boolean

    Determines whether users can add new comments to a Quip thread. If true, users can add new comments. If false, users can't add new comments.

    Responses

    Response samples

    Content type
    application/json
    {
    • "property1": "success",
    • "property2": "success"
    }

    Export Document to .docx

    Exports your specified Quip document to a DOCX file.

    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    thread_id
    required
    string

    The ID or secret path of the thread for the document you want to export.

    Responses

    Response samples

    Content type
    application/json
    {
    • "error": "string",
    • "error_code": 400,
    • "error_description": "string"
    }

    Export Slides to .pdf

    Exports your specified Quip slide deck to PDF.

    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    thread_id
    required
    string

    The ID or secret path of the thread for the document you want to export.

    Responses

    Response samples

    Content type
    application/json
    {
    • "error": "string",
    • "error_code": 400,
    • "error_description": "string"
    }

    Retrieve Export PDF Response

    Returns the status and PDF URL after a request you made to export a Quip document or Quip spreadsheet to PDF using the Create Export PDF Request API method. You can use the PDF to mark an approval cycle as complete, take a record-keeping snapshot, or share information with your leadership or with customers.

    Note:

    • Depending on the size of a thread, it can take up to 10 minutes to complete the PDF export. If you call the Retrieve Export PDF
    • Response API method and your PDF isn't available, wait a few minutes then make the call again.
    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    thread_id
    required
    string

    ID of the thread whose document you requested a PDF export for using the Create Export PDF Request API method.

    query Parameters
    request_id
    required
    string

    ID returned by the Create Export PDF Request API method. Use this value to get the status and PDF URL after calling the Create Export PDF Request API method.

    Responses

    Response samples

    Content type
    application/json

    Create Export PDF Request

    Submits a request to asynchronously export a Quip document or Quip spreadsheet to PDF. This call returns a request_id. Pass that request_id into the Retrieve Export PDF Response call to get the PDF URL and request status. Sample use cases: You can export a document or spreadsheet to PDF to mark an approval cycle as complete, take a record-keeping snapshot, or share the PDF with your leadership or with customers.

    Note:

    • Depending on the size of a thread, it can take up to 10 minutes to complete the PDF export. If you call the Retrieve Export PDF Response API method and your PDF isn't available, wait a few minutes then make the call again.

    • You can use this API method to complete a PDF export of a standalone Quip spreadsheet, not a spreadsheet inserted into a Quip document. When you do a PDF export of a Quip document containing a spreadsheet, the spreadsheet appears in the PDF.

    • You can export a maximum of 40,000 cells in a spreadsheet to PDF.

    • Charts in spreadsheets are excluded from the exported PDF.

    • The appearance of the PDF exported using this API method is typically the same as if you exported a document or spreadsheet to PDF in the Quip application. Sometimes there are differences when you export via API. For example, in the PDF:

      • Bullets look bigger.
      • Emojis aren't displayed. They're replaced with boxes in the PDF.
      • In large spreadsheets or spreadsheets that break across pages, some of the data is hidden.
      • Live apps and graphics are distorted.
      • Page breaks appear in the middle of content (such as a live app) that's supposed to be kept on the same page.
      • Some Salesforce data is hidden based on permissions set by the Salesforce admin.
    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    thread_id
    required
    string

    ID of the Quip document or spreadsheet that you want to export to PDF.

    query Parameters
    destination_thread_id
    string

    ID of the Quip document to which you want to attach the exported PDF. The PDF gets attached to the end of your specified document.

    salesforce_org_id
    string

    ID of the Salesforce organization in which you want to attach the exported PDF. If you pass in a salesforce_org_id, you must also pass in a salesforce_record_id.

    salesforce_record_id
    string

    ID of the Salesforce record to which you want to attach the exported PDF. If you pass in a salesforce_record_id, you must also pass in a salesforce_org_id.

    sheet_name
    string

    If you're exporting a spreadsheet with multiple tabs, this field identifies the tab that you want to export to PDF. If you don't identify the tab, the first tab is exported.

    apply_print_options
    boolean
    Default: false

    Determines whether to apply print options to the exported PDF. Allowable values are: * true: Apply these print options to the PDF: Include all headers and footers Show collapsed content Remove web formatting * false: Don't apply print options to the PDF.

    Responses

    Response samples

    Content type
    application/json
    {
    • "request_id": "IAcAAAY7zCRAMXAEA8lSEj1644527357113",
    • "status": "PROCESSING"
    }

    Export Spreadsheet to .xlsx

    Exports your specified Quip spreadsheet to an XLSX file.

    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    thread_id
    required
    string

    The ID or secret path of the thread for the document you want to export.

    Responses

    Response samples

    Content type
    application/json
    {
    • "error": "string",
    • "error_code": 400,
    • "error_description": "string"
    }

    Get Thread Folders V2

    Returns the list of folders that a Quip thread (document, spreadsheet, or chat) is in. Use this API method to monitor information-sharing and improve folder organization on your Quip site.

    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    threadIdOrSecretPath
    required
    string [ 10 .. 32 ] characters

    The ID or secret path of the thread to get information about. You can pass in either of these identifiers:

    query Parameters
    cursor
    string

    A pointer to the next page of data to return. Use a cursor to incrementally get additional pages of data. When you call this API method for the first time, leave the cursor field blank. For all calls after that first one, pass in the next_cursor value returned by your previous call. Continue to call this API method with each new cursor value until the next_cursor field returns empty.

    limit
    number

    The maximum number of items to return in the same call.

    Responses

    Response samples

    Content type
    application/json
    {
    • "folders": [
      ],
    • "response_metadata": {
      }
    }

    Get Thread V2

    Returns basic information about a Quip thread (document, spreadsheet, or chat). This information includes things such as the ID, title, last time the thread was edited and the thread's link sharing settings.

    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    threadIdOrSecretPath
    required
    string [ 10 .. 32 ] characters

    The ID or secret path of the thread to get information about. You can pass in either of these identifiers:

    Responses

    Response samples

    Content type
    application/json
    {
    • "thread": {
      }
    }

    Get Thread Html V2

    Get the body of the thread in html format.

    If Mirrored Salesforce Permissions is enabled, data included in a document by using a Salesforce Data Mention is returned only if the data mention has been displayed to the requesting user.

    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    threadIdOrSecretPath
    required
    string [ 10 .. 32 ] characters

    The ID or secret path of the thread you want to modify. You can pass in either of these identifiers:

    query Parameters
    cursor
    string

    A pointer to the next page of data to return. Use a cursor to incrementally get additional pages of data. When you call this API method for the first time, leave the cursor field blank. For all calls after that first one, pass in the next_cursor value returned by your previous call. Continue to call this API method with each new cursor value until the next_cursor field returns empty.

    limit
    number

    The maximum number of items to return in the same call.

    Responses

    Response samples

    Content type
    application/json
    {
    • "html": "<h1 id='SUUACAWNxIJ'>Welcome to Quip</h1><p id='SUUACAxnYSJ' class='line'>Quip lets you do much more than just create and edit documents online. Try it out and see for yourself!</p>",
    • "response_metadata": {
      }
    }

    Get Thread Invited Members V2

    Returns the list of users who were invited via email to become direct members of a Quip thread (document, spreadsheet, or chat). Use this API method to monitor requests for collaboration with people outside of your Quip site.

    Note: This API method doesn't return the list of users who are already direct members of a thread.

    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    threadIdOrSecretPath
    required
    string [ 10 .. 32 ] characters

    The ID or secret path of the thread you want to modify. You can pass in either of these identifiers:

    query Parameters
    cursor
    string

    A pointer to the next page of data to return. Use a cursor to incrementally get additional pages of data. When you call this API method for the first time, leave the cursor field blank. For all calls after that first one, pass in the next_cursor value returned by your previous call. Continue to call this API method with each new cursor value until the next_cursor field returns empty.

    limit
    number

    The maximum number of items to return in the same call.

    Responses

    Response samples

    Content type
    application/json
    {
    • "invited_members": [
      ],
    • "response_metadata": {
      }
    }

    Lock or Unlock a Thread

    Lock or unlock edits to a thread.

    Authorizations:
    OAuth2 (USER_MANAGE)
    header Parameters
    Content-Type
    string
    Example: application/x-www-form-urlencoded
    Request Body schema: application/x-www-form-urlencoded
    thread_id
    required
    string

    The ID or secret path of the thread whose document you want to modify.

    edits_disabled
    required
    boolean

    If true this will disable edits on this thread. If false, it will enable edits on this thread.

    Responses

    Response samples

    Content type
    application/json
    { }

    Lock or Unlock a Section

    Lock or unlock edits to a section.

    Authorizations:
    OAuth2 (USER_MANAGE)
    header Parameters
    Content-Type
    string
    Example: application/x-www-form-urlencoded
    Request Body schema: application/x-www-form-urlencoded
    thread_id
    required
    string

    The ID or secret path of the thread you want to modify.

    section_id
    required
    string

    The ID for the section you want to lock or unlock.

    edits_disabled
    required
    string

    If true this will disable edits for this section. If false, it will enable edits for this thread.

    Responses

    Response samples

    Content type
    application/json
    {
    • "thread": {
      },
    • "user_ids": [
      ],
    • "shared_folder_ids": [
      ],
    • "expanded_user_ids": [
      ],
    • "invited_user_emails": [ ],
    • "access_levels": {
      },
    • "html": "..."
    }

    Create a Live Paste Section In a Document

    Add a section to a document that tracks another section and can automatically update when the source section is updated.

    We determine where to insert the new content based on the location argument. Some location values are relative to another section, which is specified by destination_section_id, enabling fine-grained editing. For example, to add a section to the end of an existing section, you would send the ID of the existing section in the list as the destination_section_id and send 2: AFTER_SECTION as the location.

    To get the IDs of sections in an existing document, parse the HTML returned by the Get Thread. Every paragraph, list item, and table cell will have an HTML id attribute you can use in this method. Live Paste does not support individual items in lists.

    Alternatively the content of both the source and the destination document can be referred to by document ranges. A document range is a heading plus all sections underneath it up to the next heading of same or larger size. The location values 6, 7 and 8 support document ranges in combination with destination_document_range for the destination document. The is_document_range_source parameter supports document ranges for the source document when set to True, in combination with the source_document_range parameter. Document ranges are available for documents only, i.e. not for spreadsheets.

    Authorizations:
    OAuth2 (USER_READUSER_WRITE)
    header Parameters
    Content-Type
    string
    Example: application/x-www-form-urlencoded
    Request Body schema: application/x-www-form-urlencoded
    source_thread_id
    required
    string

    The ID or secret path of the thread to copy from.

    destination_thread_id
    required
    string

    The ID of the thread you want to modify.

    is_document_range_source
    boolean
    Default: false

    If true, source_document_range is required and is where the content of the source thread is acquired. If source_section_ids is provided in this case, an error will be returned.

    If false, the content is referenced by source_section_ids. In this case, source_section_ids is required and an error is returned if source_document_range is provided.

    source_section_ids
    string

    A comma-separated list of sequential sections of the source thread to copy. Required if is_document_range_source is set to false.

    source_document_range
    string

    The string of the heading in the source document that defines the document range you want to copy. The document range includes the header and all sections below it until the next heading of the same size or larger. This parameter is required if is_document_range_source is set to true.

    location
    string
    Default: 0
    Enum: 1 2 3 4 6 7 8 9

    Where we should insert the new content.

    • 0: APPEND - Append to the end of the document.

    • 1: PREPEND - Prepend to the beginning of the document.

    • 2: AFTER_SECTION - Insert after the section specified by section_id.

    • 3: BEFORE_SECTION - Insert before the section specified by section_id.

    • 4: REPLACE_SECTION - Delete the section specified by section_id and insert the new content at that location.

    • 6: AFTER_DOCUMENT_RANGE - Insert after the document range specified by document_range.

    • 7: BEFORE_DOCUMENT_RANGE - Insert before the document range specified by document_range.

    • 8: REPLACE_DOCUMENT_RANGE - Delete the document range specified by document_range and insert the new content at that location.

    (5 is intentionally omitted to have same numbering scheme as the edit-document endpoint.) Options 6, 7 and 8 work only on documents.

    destination_section_id
    string

    The ID or secret path of the thread to be modified. This cannot be the same as the source_thread_id. Required for location values 6 - 8.

    destination_document_range
    string

    The string of the header in the destination document that defines the document range you want to modify. Required for location values 1 - 4

    update_automatic
    string
    Default: true

    If set to true, the destination section will update automatically when the source section changes. Live Pastes will not be able to update automatically if the admin has disabled automatic updates for Live Paste in the Admin Console.

    Responses

    Response samples

    Content type
    application/json
    Example
    {
    • "thread": {
      },
    • "user_ids": [
      ],
    • "shared_folder_ids": [ ],
    • "expanded_user_ids": [
      ],
    • "invited_user_emails": [ ],
    • "html": "<h1 id='SIdACAn15zN'>Test destination document</h1>\n<p id='SIdACAAhXse' class='line'>​</p>\n<p id='SIdACAYNoUk' class='line'>​</p>\n"
    }

    Get Thread Members V2

    Returns the list of users who are members of a Quip thread (document, spreadsheet, or chat) because they were added to it directly. Use this API method to monitor information-sharing on your Quip site.

    Note: This API method doesn't return the list of users who were added via other means including:

    • Folder-sharing
    • Link-sharing
    • Salesforce Synced Sharing
    • Email invitation.
    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    threadIdOrSecretPath
    required
    string [ 10 .. 32 ] characters

    The ID or secret path of the thread to get information about. You can pass in either of these identifiers:

    query Parameters
    cursor
    string

    A pointer to the next page of data to return. Use a cursor to incrementally get additional pages of data. When you call this API method for the first time, leave the cursor field blank. For all calls after that first one, pass in the next_cursor value returned by your previous call. Continue to call this API method with each new cursor value until the next_cursor field returns empty.

    limit
    number

    The maximum number of items to return in the same call.

    Responses

    Response samples

    Content type
    application/json
    {
    • "members": [
      ],
    • "response_metadata": {
      }
    }

    Get Threads V2

    Bulk variant of the Get Thread endpoint.

    Returns basic information about multiple Quip threads (documents, spreadsheets, or chats). This information for each thread includes things such as the ID, title, last time the thread was edited and the thread's link sharing settings.

    Authorizations:
    OAuth2 (USER_READ)
    query Parameters
    ids
    required
    string

    The IDs or secret paths of the threads to get information about. You can pass in a maximum of 100 of either of these identifiers:

    • ID: You can find this in the "id" response field of the Get Thread API method.

    • secret path: You can find this in the URL of a thread. For example, in this URL: "https://quip.com/3fs7B2leat8/TrackingDocument", the secret path is 3fs7B2leat8. You can also find this ID in the "secret_path" response field of this API method.

    Responses

    Response samples

    Content type
    application/json
    {
    • "klUsAqWxr8Ne": {
      },
    • "abcAAA78901": {
      }
    }

    Create a Chat Room

    Creates a chat room.

    Authorizations:
    OAuth2 (USER_WRITE)
    header Parameters
    Content-Type
    string
    Example: application/x-www-form-urlencoded
    Request Body schema: application/x-www-form-urlencoded
    title
    required
    string

    The title of the new chat room. Title length must not exceed 10 KB.

    message
    string

    Plain text content of the new message that is posted by the author of the chat room. Content must not exceed 100KB.

    member_ids
    string

    A comma-separated list of user IDs to add as members to the chat room.

    Responses

    Response samples

    Content type
    application/json
    {
    • "thread": {
      },
    • "user_ids": [
      ],
    • "shared_folder_ids": [
      ],
    • "expanded_user_ids": [
      ],
    • "invited_user_emails": [ ],
    • "access_levels": {
      },
    • "html": "..."
    }

    Create a Document or Spreadsheet

    Creates a document or spreadsheet, returning the new thread in the same format as Get Thread.

    This endpoint doesn't support slides anymore because they're retired as described in this article.

    Authorizations:
    OAuth2 (USER_WRITE)
    header Parameters
    Content-Type
    string
    Example: application/x-www-form-urlencoded
    Request Body schema: application/x-www-form-urlencoded
    content
    required
    string

    The HTML or Markdown content of the new document. The content length must not exceed 1MB.

    NOTE: When creating a spreadsheet, the content must be surrounded by an HTML <table> tag.

    NOTE: In the current implementation, the parser treats <th> tags as <td> tags. When more than one <tr> tag is supplied, then the first row is automatically interpreted as the column header. If you want to create a table with more than one row and have default headers, then provide the first row with empty <td> tags.

    format
    string
    Default: "html"
    Enum: "html" "markdown"

    Format of the supplied document content.

    title
    string

    The title of the new document. If not specified, we infer the title from the first content of the document, for example, the first heading. The title must not exceed 10 KB.

    member_ids
    string

    A comma-separated list of folder IDs or user IDs. The document will be placed in the specified folders, and any individual users listed will be granted individual access to the document. If this argument is not given, the document is created in the authenticated user's Private folder.

    type
    string
    Default: "document"
    Enum: "document" "spreadsheet"

    The type of document to create.

    Responses

    Response samples

    Content type
    application/json
    {
    • "thread": {
      },
    • "user_ids": [
      ],
    • "shared_folder_ids": [
      ],
    • "expanded_user_ids": [
      ],
    • "invited_user_emails": [ ],
    • "access_levels": {
      },
    • "html": "..."
    }

    Get Recent Threads

    Returns the most recent threads to have received messages, similar to the updates view in the Quip app. Results are returned in the same format as Get Thread.

    Authorizations:
    OAuth2 (USER_READ)
    query Parameters
    count
    integer [ 1 .. 50 ]
    Default: 10

    The number of threads to return.

    max_updated_usec
    integer <int64>

    UNIX epoch timestamp. Searches only for threads that were last updates before or at this timestamp.

    include_hidden
    boolean

    If true, response includes hidden threads.

    Responses

    Response samples

    Content type
    application/json
    {
    • "property1": {
      },
    • "property2": {
      }
    }

    Remove People from a Thread or Remove a Thread from Folders

    Removes the given individuals from the given thread and/or removes the thread from the given folders. We return the updated thread in same format as Get Thread.

    Authorizations:
    OAuth2 (USER_MANAGE)
    header Parameters
    Content-Type
    string
    Example: application/x-www-form-urlencoded
    Request Body schema: application/x-www-form-urlencoded
    thread_id
    required
    string

    The ID or secret path of the thread from which you want to remove folders and users.

    member_ids
    required
    string

    A comma-separated list of folder IDs and user IDs. We remove each user ID individually from the thread. We remove the thread from each of the specified folder IDs.

    Responses

    Response samples

    Content type
    application/json
    {
    • "thread": {
      },
    • "user_ids": [
      ],
    • "shared_folder_ids": [
      ],
    • "expanded_user_ids": [
      ],
    • "invited_user_emails": [ ],
    • "access_levels": {
      },
    • "html": "..."
    }

    Search for Threads

    Returns a list of threads whose content matches words in the given query. Threads are sorted from most to least relevant.

    Authorizations:
    OAuth2 (USER_READ)
    query Parameters
    query
    required
    string
    Example: query=<query>

    A text string containing words delimited by spaces used to match thread content or titles.

    count
    integer <= 50
    Default: 10

    The maximum number of results to return.

    only_match_titles
    boolean
    Default: false

    If set to true, the search will match words in document titles rather than content. Typically much faster if you only want to get documents with a certain title.

    Responses

    Response samples

    Content type
    application/json
    [
    • {
      },
    • {
      },
    • {
      }
    ]

    Get a Blob from a Thread

    Gets an image or other blob from the Quip document or spreadsheet associated with your specified thread_id. To find the blob_id, inspect the Quip document or spreadsheet in a browser and search for the blob_id in the "sources".

    Response

    In the case of success, the response is raw binary, so this endpoint can be used to display images.

    In the case of failure, the response will return an object with an error field.

    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    thread_id
    required
    string

    The ID or secret path of the thread the blob belongs to.

    blob_id
    required
    string

    The ID of the blob to retrieve.

    header Parameters
    If-None-Match
    string

    Header containing a blob_id. If this ID matches the path parameter blob_id and the blob exists, an HTTP status code 304 is returned.

    Responses

    Response samples

    Content type
    application/json
    {
    • "error": "string",
    • "error_code": 304,
    • "error_description": "string"
    }

    Add a Blob to a Thread

    Uploads an image or other blob to the given thread. Returns a url that may be used in the content field of Edit Document requests and an id that may be used in the attachment field of Add a Message.

    Authorizations:
    OAuth2 (USER_WRITE)
    path Parameters
    thread_id
    required
    string

    The ID or secret path of the thread the blob will be added to.

    Request Body schema: application/x-www-form-urlencoded
    blob
    required
    string <binary>

    The image or blob binary.

    Responses

    Response samples

    Content type
    application/json
    {
    • "id": "DiPp1ZQyC8QUtvBT4vojzM",
    • "url": "/blob/LeSAAAqaCfc/DiPp1ZQyC8QUtvBT4vojzM"
    }

    Messages

    Get Recent Messages

    Returns a list of the most recent messages for the given thread.

    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    thread_id
    required
    string

    The ID of the thread to return recent messages for.

    query Parameters
    count
    integer [ 1 .. 100 ]
    Default: 25

    Number of messages to return.

    max_created_usec
    integer <int64>

    A UNIX timestamp in microseconds. If given, we return messages created at and before the given timestamp. The messages will be sorted by creation time in descending order if sort_by or sorted_by are not provided. If either updated_since_usec or last_updated_since_usec is provided, this parameter is ignored.

    updated_since_usec
    integer <int64>

    A UNIX timestamp in microseconds. If given, we return messages last updated at and after the given timestamp. The messages will be sorted by last update time in ascending order if sort_by or sorted_by are not provided.

    last_updated_since_usec
    integer <int64>

    A UNIX timestamp in microseconds. If given, we return messages last updated before the given timestamp. The messages will be sorted by last update time in ascending order if sort_by or sorted_by are not provided.

    sorted_by
    string
    Enum: "ASC" "DESC"

    Determines whether to sort messages in ascending or descending order.

    sort_by
    string
    Enum: "ASC" "DESC"

    Alias for sorted_by.

    message_type
    string
    Default: "message"
    Enum: "message" "edit"

    Determines the type of messages to return. If edit, document edit messages will be returned. Otherwise, regular messages will be returned.

    Responses

    Response samples

    Content type
    application/json
    [
    • {
      }
    ]

    Add a Message

    Adds a required chat message, which can either be plain text content or contain attachments, to the given thread, posted as the authenticated user.

    Authorizations:
    OAuth2 (USER_WRITE)
    header Parameters
    Content-Type
    string
    Example: application/x-www-form-urlencoded
    Request Body schema: application/x-www-form-urlencoded
    thread_id
    required
    string

    The ID of the thread the message will be added to.

    frame
    string
    Enum: "bubble" "card" "line"

    Adjusts the display type of the message.

    content
    string

    Plain text content of the new message (ignored if parts is supplied). There is a maximum size of 100kb per message.

    silent
    boolean
    Default: false

    If set to True, we do not send any push notifications or emails for the message. If set to False, we use the default notifications for users on the thread.

    parts
    Array of Array of strings (message_parts_input) <= 20 items [ items 2 items ]

    A list of the rich content parts of this message. Each rich content part is represented as a two-item list.

    The first list item describes the style of the message. Possible values are:

    • system
    • body
    • monospace
    • status

    The second list item is the content of the message part, in HTML.

    Rich content parts may also include user mentions. Users can be mentioned with a link to their user ID appended to the end of the Quip URL or with their email: [["body", "<a href=https://quip.com/{user_id}>User name</a>"]] or [["body", "<a href=mailto:{user_email}>User name</a>"]]

    For mentioning everyone in a document, a link to @everyone is included: [["body", "<a href='@everyone'></a>"]]

    attachments
    string

    A comma-separated list of blob IDs previously uploaded to this thread with Add a Blob.

    annotation_id
    string

    The ID of a document comment. If provided, the message will be placed in the comment. Only one of annotation_id and section_id are allowed.

    section_id
    string

    If present, the message will be added as a comment on the document section with this ID. Only one of section_id and annotation_id are allowed.

    name
    string

    The name of the apparent user if the authorized user of this request is a bot. This is for messages created from a Quip integration.

    user_id
    string

    The Quip user ID of the apparent user if the authorized user of this request is a bot. This is for messages created from a integration.

    profile_picture
    string

    The URL for the profile picture of the apparent user if the authorized user of this request is a bot. This is for messages created from a Quip integration.

    email
    string

    The email of the apparent user if the authorized user of this request is a bot. This is for messages created from a Quip integration.

    service_id
    string

    An external service ID for the message if the authorized user of this request is a bot. This is for messages created from a Quip integration and is used to prevent integrations from duplicating messages.

    url
    string

    An external URL linked from the message if the authorized user of this request is a bot. This is for messages created from a Quip integration.

    Responses

    Response samples

    Content type
    application/json
    {
    • "id": "FCKADA33rNg",
    • "author_id": "UTUAEAiZl6B",
    • "author_name": "Jane Doe",
    • "created_usec": 1632348632519081,
    • "updated_usec": 1632348632596233,
    • "visible": true,
    • "text": "string",
    • "files": [
      ],
    • "annotation": {
      },
    • "parts": [
      ],
    • "apparent_user": {
      },
    • "diff_groups": [
      ],
    • "like_user_ids": [
      ],
    • "mention_user_ids": [
      ]
    }

    Folders

    Add People to a Folder

    Shares the given folder with the given user IDs.

    Authorizations:
    OAuth2 (USER_MANAGE)
    query Parameters
    include_chats
    boolean

    If true, the children list in the response will include chat and channel thread IDs.

    header Parameters
    Content-Type
    string
    Example: application/x-www-form-urlencoded
    Request Body schema: application/x-www-form-urlencoded
    folder_id
    required
    string

    The ID of the folder to update.

    member_ids
    required
    string

    A comma-separated list of user IDs.

    Responses

    Response samples

    Content type
    application/json
    {
    • "folder": {
      },
    • "member_ids": [
      ],
    • "children": [
      ]
    }

    Get Folder

    Returns the given folder. To find your desktop or archive folder ID, see Get Authenticated User.

    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    id
    required
    string

    ID of the folder whose information you want to get.

    query Parameters
    include_chats
    boolean

    If true, the children list in the response will include chat and channel thread IDs.

    Responses

    Response samples

    Content type
    application/json
    {
    • "folder": {
      },
    • "member_ids": [
      ],
    • "children": [
      ]
    }

    Get Folder Link Sharing Settings

    Identifies the link sharing settings for your specified folder.

    See also

    Link Share Folders

    Sample Call

    In this example, we're getting the link sharing settings for a folder with ID XaABCAlgycE.

    GET https://platform.quip.com/2/folders/XaABCAlgycE/link-sharing-settings
    Authorization: Bearer ABCSampleAccessToken
    
    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    folderIdOrSecretPath
    required
    string [ 10 .. 32 ] characters

    Identifier of the folder whose link sharing settings you want to get. You can pass in either of these identifiers:

    • folder_id: Identifier returned in the id field when you call the Get Folder API method.

    • secret path: 12-character identifier that you can find in the URL of the folder. For example, the secret path is "N5aaOTih0VYy" in this URL: "https://quip.com/N5aaOTih0VYy/TeamFolder".

    Responses

    Response samples

    Content type
    application/json
    [
    • {
      }
    ]

    Edit Folder Link Sharing Settings

    Modifies a Quip folder's link sharing settings. When you enable link sharing on a folder, everyone at your company can view, edit, and share the contents of that folder. You can also use this API method to enable or disable read-only access for people outside of your company.

    For example, if you have a folder that contains data to be shared with your whole company, you can enable link sharing on the folder. That way, all employees can use the shareable link to automatically get access to any new or updated content in that folder. If you enable external access, people your employees collaborate with outside of your company also automatically get access to that content.

    See also

    Link Share Folders

    Sample Call

    In this example, we're enabling link sharing on a folder with ID XaABCAlgycE.

    PUT https://platform.quip.com/2/folders/XaABCAlgycE/link-sharing-settings
    Content-Type: application/json
    Authorization: Bearer ABCSampleAccessToken
    
    {
        "link_sharing_enabled": "True",
        "external_access_allowed": "False"
    }
    
    Authorizations:
    OAuth2 (USER_MANAGE)
    path Parameters
    folderIdOrSecretPath
    required
    string [ 10 .. 32 ] characters

    Identifier of the folder whose link sharing settings you want to get. You can pass in either of these identifiers:

    • folder_id: Identifier returned in the id field when you call the Get Folder API method.

    • secret path: 12-character identifier that you can find in the URL of the folder. For example, the secret path is "N5aaOTih0VYy" in this URL: "https://quip.com/N5aaOTih0VYy/TeamFolder".

    Request Body schema: application/json
    link_sharing_enabled
    required
    boolean

    Determines whether to enable link sharing for your specified folder. Allowable values are:

    • True: Enable link sharing.
    • False: Disable link sharing.
    external_access_allowed
    boolean

    Determines whether people outside of your company can access your specified folder. This field is required only if you set link_sharing_enabled to True. Allowable values are:

    • True: Enable external access.
    • False: Disable external access.

    Responses

    Request samples

    Content type
    application/json
    [
    • {
      }
    ]

    Response samples

    Content type
    application/json
    {
    • "error": "string",
    • "error_code": 400,
    • "error_description": "string"
    }

    Get Folders

    Bulk variant of the Get Folder endpoint. Returns an object mapping IDs to folder objects.

    Authorizations:
    OAuth2 (USER_READ)
    query Parameters
    ids
    required
    string
    Example: ids=BULAOADdLWL,CULAOADdLWL

    A comma-separated list of folder IDs.

    include_chats
    boolean

    If true, the children list in the response will include chat and channel thread IDs.

    Responses

    Response samples

    Content type
    application/json
    {
    • "property1": {
      },
    • "property2": {
      }
    }

    Create a Folder

    Creates a folder.

    Authorizations:
    OAuth2 (USER_MANAGE)
    query Parameters
    include_chats
    boolean

    If true, the children list in the response will include chat and channel thread IDs.

    Request Body schema: application/x-www-form-urlencoded
    title
    required
    string

    The name of the folder.

    color
    string
    Default: "manila"
    Enum: "manila" "red" "orange" "green" "blue" "purple" "dark_yellow" "light_red" "light_orange" "light_green" "light_blue" "light_purple"

    The color of the folder.

    member_ids
    string

    A comma-separated list of user IDs to add as members of this folder.

    parent_id
    string

    If given, we make the folder a child of the given folder. If not given, we create the folder in the authenticated user's Private folder.

    Responses

    Response samples

    Content type
    application/json
    {
    • "folder": {
      },
    • "member_ids": [
      ],
    • "children": [
      ]
    }

    Remove People from a Folder

    Removes the given User IDs from the given folder.

    Authorizations:
    OAuth2 (USER_MANAGE)
    query Parameters
    include_chats
    boolean

    If true, the children list in the response will include chat and channel thread IDs.

    Request Body schema: application/x-www-form-urlencoded
    folder_id
    required
    string

    The ID of the folder to modify.

    member_ids
    required
    string

    A comma-separated list of user IDs.

    Responses

    Response samples

    Content type
    application/json
    {
    • "folder": {
      },
    • "member_ids": [
      ],
    • "children": [
      ]
    }

    Update a Folder

    Updates a folder.

    Authorizations:
    OAuth2 (USER_MANAGE)
    query Parameters
    include_chats
    boolean

    If true, the children list in the response will include chat and channel thread IDs.

    Request Body schema: application/x-www-form-urlencoded
    folder_id
    required
    string

    The ID of the folder to update.

    title
    string

    The new title of the folder.

    color
    string
    Enum: "manila" "red" "orange" "green" "blue" "purple" "dark_yellow" "light_red" "light_orange" "light_green" "light_blue" "light_purple"

    The new color of the folder.

    Responses

    Response samples

    Content type
    application/json
    {
    • "folder": {
      },
    • "member_ids": [
      ],
    • "children": [
      ]
    }

    Users

    Get Contacts

    Returns a list of contacts for the authenticated user.

    Authorizations:
    OAuth2 (USER_READ)

    Responses

    Response samples

    Content type
    application/json
    Example
    [ ]

    Get Current User

    Returns information about the authenticated user.

    Authorizations:
    OAuth2 (USER_READ)
    query Parameters
    sort_by
    string
    Enum: "title" "created_usec" "updated_usec"

    Determines which field to sort the shared_folder_ids and group_folder_ids lists by.

    sort_order
    string
    Default: "asc"
    Enum: "asc" "desc"

    Determines what order to sort the shared_folder_ids and group_folder_ids lists by. asc sorts the lists in ascending order while desc sorts the lists in descending order.

    Responses

    Response samples

    Content type
    application/json
    {
    • "id": "UTUAEAiZl6B",
    • "name": "Jane Doe",
    • "company_id": "IMbAcASGu56",
    • "emails": [
      ],
    • "disabled": false,
    • "created_usec": 1632022665732239,
    • "is_robot": false,
    • "affinity": 0.43,
    • "chat_thread_id": "adHAAAKik9A",
    • "desktop_folder_id": "AGWAOAhT3qk",
    • "archive_folder_id": "BGWAOAhT3qk",
    • "starred_folder_id": "CGWAOAhT3qk",
    • "private_folder_id": "DGWAOAhT3qk",
    • "trash_folder_id": "EGWAOAhT3qk",
    • "shared_folder_ids": [
      ],
    • "group_folder_ids": [
      ]
    }

    Get Current User's Threads

    Returns information about Quip threads owned by the current user. Threads include: documents and spreadsheets, chats (2-person and group), Slack channel conversations linked to Quip (also called "channels"), and slides. You can use the returned information for eDiscovery and eArchiving purposes. For example, you can pass the returned thread IDs into another API call to export the threads to .docx or PDF files. Then you can save the exported files in your archiving system.

    Sample Calls

    In this first example, we're getting a list of the first 50 threads owned by the current user. Since the user owns more that 50 threads, we'll get a next_cursor value in the response and pass that value into the next call in step 2.

    GET https://platform.quip.com/1/users/current/threads?limit=50
    Authorization: Bearer {{ABCSampleAccessToken}}
    

    In this example, we're getting a list of the next 50 threads owned by a user with ID ABCEAmpgev at a company with ID DEFAcAV4DT7. We're passing in the next_cursor value returned by the previous call from step 1.

    GET https://platform.quip.com/1/users/current/threads?limit=50&cursor=bmV4dCBjdXJzb3I
    Authorization: Bearer {{ABCSampleAccessToken}}
    
    Authorizations:
    OAuth2 (USER_READ)
    query Parameters
    threads_meta
    boolean
    Default: false

    Determines whether to include basic thread data in the response. Allowable values for this field are:

    • true: Return thread_id, updated_usec, link, and is_deleted on each thread.

    • false: Return thread_id on each thread.

    include_deleted
    boolean
    Default: false

    Determines whether to return threads that the current user has been removed from. Allowable values for this field are:

    • true: Return threads that the user has been removed from.

    • false: Don't return threads that the user has been removed from.

    thread_ids
    string
    Example: thread_ids=UcZ9AAhvqrc,AVN9AAeqq5w

    Comma-separated list of thread IDs owned by the current user. You can pass in either of these identifiers:

    limit
    integer

    The maximum number of threads to return. You can pass in a maximum limit of 1,000. If you leave the limit field blank, this call returns a maximum of 1,000 threads.

    cursor
    string

    A pointer to the next page of thread data to return. Use a cursor to incrementally get the next set of thread data. When you call this API method for the first time, leave the cursor field blank. For all calls after that first one, pass in the next_cursor value returned by your previous Get User's Threads call. Continue to call Get User's Threads with each new cursor value until the next_cursor field returns empty.

    Note: Each next_cursor value returned by this API method expires 30 minutes after creation. After a cursor expires, you can call Get User's Threads again to get a new cursor.

    Responses

    Response samples

    Content type
    application/json
    Example
    {
    • "threads": {
      },
    • "response_metadata": {
      }
    }

    Get User

    Returns the user with the specified ID.

    Authorizations:
    OAuth2 (USER_READ)
    path Parameters
    id
    required
    string

    The ID or email address of the user to get information for. Note: Email-based lookups return information about a user from only the same company as the caller. That's the company of the person who created the API key associated with your provided access token.

    query Parameters
    sort_by
    string
    Enum: "title" "created_usec" "updated_usec"

    Determines which field to sort the shared_folder_ids and group_folder_ids lists by, if they're included in the response.

    sort_order
    string
    Default: "asc"
    Enum: "asc" "desc"

    Determines what order to sort the shared_folder_ids and group_folder_ids lists by, if they're included in the response. asc sorts the lists in ascending order while desc sorts the lists in descending order.

    Responses

    Response samples

    Content type
    application/json
    {
    • "id": "UTUAEAiZl6B",
    • "name": "Jane Doe",
    • "company_id": "IMbAcASGu56",
    • "emails": [
      ],
    • "disabled": false,
    • "created_usec": 1632022665732239,
    • "is_robot": false,
    • "affinity": 0.43,
    • "chat_thread_id": "adHAAAKik9A",
    • "desktop_folder_id": "AGWAOAhT3qk",
    • "archive_folder_id": "BGWAOAhT3qk",
    • "starred_folder_id": "CGWAOAhT3qk",
    • "private_folder_id": "DGWAOAhT3qk",
    • "trash_folder_id": "EGWAOAhT3qk",
    • "shared_folder_ids": [
      ],
    • "group_folder_ids": [
      ]
    }

    Get Users

    Bulk variant of the Get User endpoint. Returns an object with the passed in user IDs or emails as properties and user objects as values. If a user ID or email is not found, then its value will be an error message instead.

    Authorizations:
    OAuth2 (USER_READ)
    query Parameters
    ids
    required
    string

    A comma-separated list of either emails or user IDs. Must not exceed 1000 emails or user IDs. Note: Email-based lookups return information about a user from only the same company as the caller. That's the company of the person who created the API key associated with your provided access token.

    sort_by
    string
    Default: "asc"
    Enum: "title" "created_usec" "updated_usec"

    Determines which field to sort the shared_folder_ids and group_folder_ids lists by, if they're included in the response.

    sort_order
    string
    Enum: "asc" "desc"

    Determines what order to sort the shared_folder_ids and group_folder_ids lists by, if they're included in the response. asc sorts the lists in ascending order while desc sorts the lists in descending order.

    Responses

    Response samples

    Content type
    application/json
    {
    • "UTUAEAiZl6B": {
      },
    • "jane.doe@example.com": {
      }
    }

    Get Users Read Only

    Gets the read-only status of users.

    Authorizations:
    OAuth2 (USER_READ)
    query Parameters
    user_ids
    Array of strings [ 1 .. 1000 ] items
    Example: user_ids=SSSAEAOPHIA,QUEAEAENBEY

    A comma separated list of user IDs.

    Responses

    Response samples

    Content type
    application/json
    {
    • "read_only": [
      ],
    • "non_read_only": [
      ],
    • "not_found": [
      ]
    }

    Update User

    Updates the provided user. If the authenticated user is a bot user, users of the same company can be updated. Otherwise, only the authenticated user can be updated. Currently only supports updating the user's profile picture.

    Authorizations:
    OAuth2 (USER_MANAGE)
    header Parameters
    Content-Type
    string
    Example: application/x-www-form-urlencoded
    Request Body schema: application/x-www-form-urlencoded
    user_id
    string

    The ID or email address of the user to update. If not provided, the authorized user's ID is used by default.

    picture
    string <binary>

    The picture to use as the user's profile picture. One of picture or picture_url must be provided.

    picture_url
    string

    The URL to the picture to use as the user's profile picture. One of picture or picture_url must be provided.

    sort_by
    string
    Default: "asc"
    Enum: "title" "created_usec" "updated_usec"

    Determines which field to sort the shared_folder_ids and group_folder_ids lists by.

    sort_order
    string
    Enum: "asc" "desc"

    Determines what order to sort the shared_folder_ids and group_folder_ids lists by. asc sorts the lists in ascending order while desc sorts the lists in descending order.

    Responses

    Response samples

    Content type
    application/json
    {
    • "id": "UTUAEAiZl6B",
    • "name": "Jane Doe",
    • "company_id": "IMbAcASGu56",
    • "emails": [
      ],
    • "disabled": false,
    • "created_usec": 1632022665732239,
    • "is_robot": false,
    • "affinity": 0.43,
    • "chat_thread_id": "adHAAAKik9A",
    • "desktop_folder_id": "AGWAOAhT3qk",
    • "archive_folder_id": "BGWAOAhT3qk",
    • "starred_folder_id": "CGWAOAhT3qk",
    • "private_folder_id": "DGWAOAhT3qk",
    • "trash_folder_id": "EGWAOAhT3qk",
    • "shared_folder_ids": [
      ],
    • "group_folder_ids": [
      ]
    }

    Realtime

    New Websocket

    Returns a websocket URL to connect to. The URL may expire if no connection is initiated within 60 seconds.

    Websocket Events:

    Each event sent through the websocket is a JSON object with a type indicating what happened.

    type - What type of event this packet represents. The list of types include the following:

    • message - A new message was sent, includes message, user, and thread.
    • heartbeat - Periodically sent to keep the connection open.
    • alive - Reply sent if the client sends {"type": "heartbeat"}.
    • error - Sent in response to any unrecognized command, includes debug.

    message - A Quip message in the format described in Get Recent Messages.

    user - An object containing the ID and name of the user who sent the message.

    thread - An object containing the ID and title (if any) of the thread the message was sent on.

    debug - A string with additional debug information.

    Example Websocket Events:

    {
        "type": "heartbeat"
    }
    
    {
        "type": "alive"
    }
    
    {
        "type": "error",
        "debug": "Unsupported command."
    }
    
    Authorizations:
    OAuth2 (USER_READ)

    Responses

    Response samples

    Content type
    application/json
    {
    • "url": "wss://listen0.quip.com:443/platform/listen/0?t=1",
    • "user_id": "KaDAEAinU0V"
    }