Quip Automation API

https://quip.com/dev/automation/documentation/current
Admin
The Quip Automation API provides REST-based read/write access to Quip threads, documents, messages,...
Tokens:120,385
Snippets:427
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Get Quip Folder Link Sharing Settings (Sample Call)

Source: https://quip.com/dev/automation/documentation/current/index

Provides an example of an HTTP GET request to retrieve the link sharing settings for a specified Quip folder. This includes the endpoint, authorization header, and expected response format.

```http
GET https://quip.com/2/folders/XaABCAlgycE/link-sharing-settings
Authorization: Bearer ABCSampleAccessToken
```

--------------------------------

### Live App Integration Examples

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Examples of embedding various Quip Live Apps into a document using HTML and a JSON payload.

```APIDOC
## Live App Integration Examples

### Description
Examples of embedding various Quip Live Apps into a document using HTML and a JSON payload. Each example shows the `data-live-app-id` and `data-live-app-payload` attributes for different applications like Salesforce records, lists, and Kanban boards.

### Method
(Implicitly, these are for embedding content, not a specific API call, but the data attributes are key.)

### Endpoint
(Not applicable for direct API calls, used within Quip document content)

### Parameters
(These are attributes within HTML `<div>` tags)

#### Salesforce Record
- **data-live-app-id**: "XdJAjAN5Jbi"
- **data-live-app-payload**: `{
  "record_id": "0013h00000C9tHJAAZ",
  "org_id": "00D3h000004XoQgEAK" 
}`

#### Salesforce List
- **data-live-app-id**: "QYUAjAGNxIo"
- **data-live-app-payload**: `{
  "list_id": "00B3h000005lR7jEAE",
  "object_type": "Account",
  "org_id": "00D3h000004XoQgEAK" 
}`

#### Salesforce Related List
- **data-live-app-id**: "QYUAjAGNxIo"
- **data-live-app-payload**: `{
  "record_id": "0013h00000Db6YAAAZ",
  "related_list_type": "Contact",
  "org_id": "00D3h000004XoQgEAK" 
}`

#### Kanban Board
- **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"
        }
      ]
    }
  ]
}`

### Request Example
(Examples are shown as HTML snippets within the markdown itself, demonstrating the structure for embedding.)

### Response
(Not applicable, as this describes content embedding within Quip.)
```

--------------------------------

### Live Apps Integration Examples

Source: https://quip.com/dev/automation/documentation/current/index

Examples of how to embed Live Apps for various services like Salesforce and Kanban boards within Quip documents.

```APIDOC
## Live Apps Integration Examples

### Salesforce Record Integration

This Live App allows you to embed a specific Salesforce record directly into a Quip document.

**Sample HTML:**
```html
<div data-live-app-id='XdJAjAN5Jbi' data-live-app-payload='{
  "record_id": "0013h00000C9tHJAAZ",
  "org_id": "00D3h000004XoQgEAK" }'>
</div>
```

### Salesforce List Integration

This Live App enables the display of a Salesforce record list within a Quip document.

**Sample HTML:**
```html
<div data-live-app-id='QYUAjAGNxIo' data-live-app-payload='{
  "list_id": "00B3h000005lR7jEAE",
  "object_type": "Account",
  "org_id": "00D3h000004XoQgEAK" }'>
</div>
```

### Salesforce Related List Integration

Embed a related list of Salesforce records associated with a specific record.

**Sample HTML:**
```html
<div data-live-app-id='QYUAjAGNxIo' data-live-app-payload='{
  "record_id": "0013h00000Db6YAAAZ",
  "related_list_type": "Contact",
  "org_id": "00D3h000004XoQgEAK" }'>
</div>
```

### Kanban Board Integration

Create and display a Kanban board with customizable columns and cards.

**Sample HTML:**
```html
<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 Integration

Implement a project tracker with predefined columns like Project, Owner, Status, Deadline, and Attachment.

**Sample HTML:**
```html
<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>
```
```

--------------------------------

### Get Quip Folder Information (JSON Example)

Source: https://quip.com/dev/automation/documentation/current/index

Demonstrates the JSON response structure when retrieving information about a specific Quip folder. It includes details like folder title, creator, IDs, timestamps, type, sharing mode, and associated member and child thread IDs.

```json
{
  "folder": {
    "title": "Quip",
    "creator_id": "KLf9EAPrxbs",
    "id": "RKH9OAELPKV",
    "created_usec": 1497474937520657,
    "updated_usec": 1558247457514983,
    "folder_type": "shared",
    "inherit_mode": "inherit",
    "sharing": {
      "company_mode": "EDIT",
      "company_id": "LbdAcAwVVIA"
}
},
  "member_ids": [
    "YNK9EAU71mc",
    "PEW9EAtTnrV",
    "aBd9EAl8R0H",
    "MVT9EACSny8",
    "LJa9EAtQi98",
    "ROS9EAGOj1u"
],
  "children": [
    {
      "thread_id": "aXM9AASQOGr"
},
    {
      "thread_id": "cYX9AAfS6ma"
},
    {
      "thread_id": "WVD9AA1grdh"
}
]

}
```

--------------------------------

### JSON Get Thread Response Sample

Source: https://quip.com/dev/automation/documentation/current/index

Example JSON response for fetching thread details, containing author ID, creation/update timestamps, thread ID, title, and type.

```JSON
{
  "thread": {
    "author_id": "LJa9EAtQi98",
    "created_usec": 1519926805974011,
    "id": "AVN9AAeqq5w",
    "is_template": false,
    "link": "https://corp.quip.com/klUsAqWxr8Ne",
    "owning_company_id": "IMbAcASGu56",
    "secret_path": "klUsAqWxr8Ne",
    "title": "❗️ very important cat pics ❗️",
    "type": "DOCUMENT",
    "updated_usec": 1558224928731511
}
}
```

--------------------------------

### API Response Example

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Illustrates a successful API response (HTTP 200) for a thread operation, including an example of the returned thread information.

```json
responses:
  '200':
    description: Example Response
    content:
      application/json:
        schema:
          $ref: '#/components/schemas/thread_info_v1'
        examples:
          example1:
            summary: Example Response
            value:
              thread:
                author_id: HcLAEARatvR
```

--------------------------------

### JSON Get Thread Folders Response Sample

Source: https://quip.com/dev/automation/documentation/current/index

Example of a JSON response for retrieving thread folders, including folder IDs, types, and metadata for pagination.

```JSON
{
  "folders": [
    [
      {
        "folder_id": "XaABCAlgycE",
        "type": "SHARED"
      },
      {
        "folder_id": "EGFAOAZ64Jg",
        "type": "PRIVATE"
      }
    ]
  ],
  "response_metadata": {
    "next_cursor": "Y3Vyc29yVG9OZXh0UGFnZQ=="
  }
}
```

--------------------------------

### Get Thread Invited Members V2 - JSON Response Example

Source: https://quip.com/dev/automation/documentation/current/index

This JSON snippet illustrates a successful response from the Get Thread Invited Members V2 API. It lists users invited to a Quip thread via email and includes metadata for pagination.

```json
{
  "invited_members": [
    {
      "email": "abc@example.com",
      "access_level": "OWN",
      "id": "fONAVAw8BJX"
    },
    {
      "email": "def@example.com",
      "access_level": "VIEW",
      "id": "SWJAVAhaLJ6"
    }
  ],
  "response_metadata": {
    "next_cursor": "Y3Vyc29yVG9OZXh0UGFnZQ=="
  }
}
```

--------------------------------

### API Request Header Example

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Provides an example of the Content-Type header required for API requests, specifying the data format.

```http
parameters:
- name: Content-Type
  in: header
  schema:
    type: string
  example: application/x-www-form-urlencoded
```

--------------------------------

### Quip WebSocket Event Examples (Text)

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Provides examples of common WebSocket events exchanged with the Quip platform. These include heartbeat signals for maintaining the connection, an 'alive' response, and an 'error' response for unrecognized commands.

```text
{
    "type": "heartbeat"
}

{
    "type": "alive"
}

{
    "type": "error",
    "debug": "Unsupported command."
}
```

--------------------------------

### Folder Structure Example (Quip API)

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

This example demonstrates the structure of a folder object within the Quip API, including its title, creator, ID, timestamps, type, sharing mode, and associated member IDs and children threads.

```yaml
folder:
  title: Quip
  creator_id: KLf9EAPrxbs
  id: RKH9OAELPKV
  created_usec: 1497474937520657
  updated_usec: 1558247457514983
  folder_type: shared
  inherit_mode: inherit
  sharing:
    company_mode: EDIT
    company_id: LbdAcAwVVIA
member_ids:
- YNK9EAU71mc
- PEW9EAtTnrV
- aBd9EAl8R0H
- MVT9EACSny8
- LJa9EAtQi98
- ROS9EAGOj1u
children:
- thread_id: aXM9AASQOGr
- thread_id: cYX9AAfS6ma
- thread_id: WVD9AA1grdh
```

--------------------------------

### Quip API: Example Response for Live Paste with Document Ranges

Source: https://quip.com/dev/automation/documentation/current/index

Provides an example JSON response illustrating a 'Live Paste' operation with document ranges in Quip. It details thread information, user IDs, shared folder IDs, and HTML content.

```json
{
  "thread": {
    "author_id": "HcLAEARatvR",
    "thread_class": "document",
    "id": "SIdAAANKtjW",
    "created_usec": 1588263820524431,
    "updated_usec": 1588264045370339,
    "title": "Test destination document",
    "link": "https://corp.quip.com/EJGEA1dknX2g",
    "type": "document",
    "document_id": "SIdABA4DG5G"
  },
  "user_ids": [
    "HcLAEARatvR"
  ],
  "shared_folder_ids": [ ],
  "expanded_user_ids": [
    "HcLAEARatvR"
  ],
  "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"
}
```

--------------------------------

### Authentication Overview

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Guides users on how to authenticate with the Quip API, including obtaining API keys and access tokens.

```APIDOC
## Authentication

### Description

Authentication provides access to the Quip Admin and Automation APIs, enabling the creation of integrations. This section outlines the process of obtaining API keys and access tokens.

### Getting Started

1.  **Create an API Key:** Visit [this link](https://help.salesforce.com/s/articleView?id=sf.anywhere_new_api_key.htm&type=5) to create an API key.
2.  **Get an Access Token:** Use the created API key to obtain an access token as described in the section "Get Access to Quip's APIs".

### API Keys and Scopes

*   Create additional API keys for different integrations, assigning the necessary scopes for specific features.
*   A personal access token can also be generated for testing purposes at [quip.com/dev/token](https://quip.com/dev/token).

### Security Best Practices

*   **Limit Scopes:** Assign only the required scopes to API keys to protect Quip data.
*   **Token Refresh:** Tokens expire every 30 days. Use the [Token Endpoint](#operation/accessToken) to refresh tokens proactively and ensure uninterrupted user access.
*   **Verify Token Status:** Utilize the [Verify Token](#operation/verifyToken) endpoint to check token validity, expiration, and associated scopes.
*   **Revoke Tokens:** Revoke unused tokens via the [Revoke](#operation/revokeToken) endpoint or the Admin Console (Settings > Integrations > Action menu > Revoke).

### Accessing Quip's APIs

#### Personal Authentication

Generate an access token for personal API access to test the API, automate tasks, or integrate with personal services. Visit [quip.com/dev/token](https://quip.com/dev/token). Generating a new token invalidates all previous tokens.

#### OAuth Process

##### Prerequisites

*   **Admin Role:** Must be an administrator to create an API key.
*   **Admin API Access:** For the Admin API, administrators must add users to the Admin API Users list in the Admin Console (Settings > Site Settings).

**Note:** The Events API and Governance API (requires subscription) are available as add-ons.

##### Process Overview

To gain access to the Quip Admin and Automation APIs...
```

--------------------------------

### Quip Thread Object Example (JSON)

Source: https://quip.com/dev/automation/documentation/current/index

An example JSON object representing a Quip thread, including its ID, author, creation and update timestamps, title, link, type, and sharing information like user IDs, shared folder IDs, and access levels.

```json
{
  "thread": {
    "id": "AVN9AAeqq5w",
    "author_id": "LJa9EAtQi98",
    "owning_company_id": "IMbAcASGu56",
    "thread_class": "document",
    "created_usec": 1519926805974011,
    "updated_usec": 1558224928731511,
    "title": "❗️ very important cat pics ❗️",
    "link": "https://corp.quip.com/klUsAqWxr8Ne",
    "type": "document",
    "is_deleted": false,
    "is_template": false,
    "document_id": "KSRABARYWW9"
},
  "user_ids": [
    "UTUAEAiZl6B"
],
  "shared_folder_ids": [
    "RKa9OAiGmsC"
],
  "expanded_user_ids": [
    "PZF9EA0i0ef",
    "dHe9EABHRsb",
    "EHY9EAokwO3"
],
  "invited_user_emails": [ ],
  "access_levels": {
    "PZF9EA0i0ef": {
      "access_level": "OWN"
},
    "dHe9EABHRsb": {
      "access_level": "VIEW"
},
    "EHY9EAokwO3": {
      "access_level": "EDIT"
}
},
  "html": "..."

}
```

--------------------------------

### Quip Thread Data Structure Example

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

An example of the JSON structure representing a Quip thread, including its ID, author, company ID, type, timestamps, title, link, and HTML content. It also details user IDs, shared folder IDs, invited user emails, and access levels.

```json
{
  "thread": {
    "id": "AVN9AAeqq5w",
    "author_id": "LJa9EAtQi98",
    "owning_company_id": "IMbAcASGu56",
    "thread_class": "document",
    "created_usec": 1519926805974011,
    "updated_usec": 1558224928731511,
    "title": "\u2757\uFE0F very important cat pics \u2757\uFE0F",
    "link": "https://corp.quip.com/klUsAqWxr8Ne",
    "type": "document",
    "is_deleted": false,
    "is_template": false,
    "document_id": "KSRABARYWW9"
  },
  "user_ids": [
    "UTUAEAiZl6B"
  ],
  "shared_folder_ids": [
    "RKa9OAiGmsC"
  ],
  "expanded_user_ids": [
    "PZF9EA0i0ef",
    "dHe9EABHRsb",
    "EHY9EAokwO3"
  ],
  "invited_user_emails": [],
  "access_levels": {
    "PZF9EA0i0ef": {
      "access_level": "OWN"
    },
    "dHe9EABHRsb": {
      "access_level": "VIEW"
    },
    "EHY9EAokwO3": {
      "access_level": "EDIT"
    }
  },
  "html": "..."
}
```

--------------------------------

### Version Identification Example

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Illustrates how API versions are identified within the endpoint path.

```APIDOC
## API Version Identification Example

### Description
Examples demonstrating how version numbers are incorporated into API endpoints.

### Method
GET

### Endpoint
Version 1: https://platform.quip.com/1/admin/sampleresource
Version 2: https://platform.quip.com/2/admin/sampleresource

### Parameters
(No specific parameters mentioned in the text)

### Request Example
(No request example provided)

### Response
(No specific response details provided)

### Response Example
(No response example provided)
```

--------------------------------

### Get Threads V2 - Example

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Retrieves basic information for multiple Quip threads (documents, spreadsheets, chats) using their IDs or secret paths. Supports up to 100 identifiers.

```openapi
{
  "security": [
    {
      "OAuth2": [
        "USER_READ"
      ]
    }
  ],
  "tags": [
    "Threads"
  ],
  "summary": "Get Threads V2",
  "operationId": "getThreadsV2",
  "description": "Bulk variant of the\n[Get Thread](#operation/getThreadV2) endpoint.\n\nReturns basic information about multiple Quip threads\n(documents, spreadsheets, or chats). This information for each\nthread includes things such as the ID, title,\nlast time the thread was edited and the thread's\nlink sharing settings.  ",
  "parameters": [
    {
      "name": "ids",
      "in": "query",
      "schema": {
        "type": "string"
      },
      "required": true,
      "description": "The IDs or secret paths of the threads to get information about.\n  You can pass in a maximum of 100 of either of these\n  identifiers:\n\n  * `ID`: You can find this in the \"id\" response field of the\n  [Get Thread](#operation/getThread) API method.\n\n  * `secret path`: You can find this in the URL of a thread.\n  For example, in this URL:"
    }
  ]
}
```

--------------------------------

### Quip API Versioning Examples

Source: https://quip.com/dev/automation/documentation/current/index

Illustrates how API method versions are identified in the URL path. Demonstrates the structure for accessing version 1 and version 2 of an API method.

```HTTP
GET https://platform.quip.com/1/admin/sampleresource.
GET https://platform.quip.com/2/admin/sampleresource.
```

--------------------------------

### Create a Project Tracker in Quip

Source: https://quip.com/dev/automation/documentation/current/index

Sets up a project tracker with predefined columns for Project, Owner, Status, Deadline, and Attachment. Allows defining column types and options, and populating with project data.

```html
<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>
```

--------------------------------

### Get Thread Members V2 - Example

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Retrieves a list of users directly added as members to a Quip thread. This method does not include users added through folder, link, Salesforce, or email sharing.

```openapi
{
  "security": [
    {
      "OAuth2": [
        "USER_READ"
      ]
    }
  ],
  "tags": [
    "Threads"
  ],
  "summary": "Get Thread Members V2",
  "operationId": "getThreadMembersV2",
  "description": "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.\n\nNote: This API method doesn't return the list of users who were added via other means including:\n- Folder-sharing\n- Link-sharing\n- Salesforce Synced Sharing\n- Email invitation.",
  "parameters": [
    {
      "$ref": "#/components/parameters/thread_id_or_secret_path_for_get"
    },
    {
      "$ref": "#/components/parameters/cursor"
    },
    {
      "$ref": "#/components/parameters/limit"
    }
  ],
  "responses": {
    "200": {
      "description": "Successful Response",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/thread_get_members_v2_response"
          }
        }
      }
    },
    "401": {
      "$ref": "#/components/responses/401_authentication"
    },
    "403": {
      "$ref": "#/components/responses/403_forbidden"
    },
    "404": {
      "$ref": "#/components/responses/404_not_found"
    },
    "500": {
      "$ref": "#/components/responses/500_server_error"
    }
  }
}
```

--------------------------------

### API Usage Guidance and FAQs

Source: https://quip.com/dev/automation/documentation/current/index

Answers common questions about Quip's APIs, including choosing between Automation and Admin APIs, integration capabilities, managing user accounts for integrations, API key rotation, and monitoring API usage.

```APIDOC
## Quip Developer FAQ

### API Selection
**Which API should I use, the Automation API or the Admin API?**
- **Automation API:** Recommended for automating user-level processes (document copying, editing) and system integrations.
- **Admin API:** Recommended for admin-level workflows (site-wide settings, security, activity monitoring, quarantining documents).

### Integrations
**Which systems can integrate with Quip's APIs?**
Quip's APIs integrate with a wide range of systems including Salesforce, Slack, Google Workspace, Github, Jira, Stripe, Dropbox, Box, Zendesk, and custom proprietary applications.

### User Management for Integrations
**Can I create a non-human user account for my integrations?**
Yes, create a placeholder or bot user in the Quip Admin Console for integrations. This prevents disruption if an employee's account is deprovisioned and clarifies separation of duties.

### API Key Management
**Is there a way for the API keys to be rotated every 90 days automatically or would this be a manual action?**
API key rotation is currently a manual process; there is no automatic rotation feature.

### Rate Limit Scope
**Which API calls are included in rate limits?**
All Admin and Automation API calls, including those made via Process Builder and Flow, are counted towards both per-user and per-company rate limits.

### Requesting Rate Limit Increases
**Can we raise our rate limits?**
If you require higher API call frequency than the default limits allow, contact Quip Customer Support.

### Monitoring API Usage
**How do we monitor our API usage?**
Monitor API usage through the headers provided in Quip's Admin and Automation API responses.

### Engagement Reporting
**Is there an API that can run reports on Quip engagement?**
Use the Events API to retrieve engagement data, which can then be fed into your monitoring systems.

### eDiscovery and eArchiving
**What tools are available for Quip eDiscovery and eArchiving?**
Consult our trusted partner, onna.com/quip, for eDiscovery and eArchiving solutions.

### Data Export
**How do I export my Quip data?**
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 from a document. The response can be exported to other systems.

### User Deprovisioning
**How do we deprovision users?**
Use the `Disable User v1.1` or `v2.0` API method to deactivate a user account.

### Staying Updated
**Can we subscribe to news about changes to API documentation or feature updates?**
Stay informed by reading the release notes, subscribing to the Salesforce Developer newsletter, and following Salesforce Developer social media channels (Twitter, LinkedIn, Facebook).

### Further Assistance
**More questions?**
Ask other Quip developers on Salesforce Stack Exchange.
```

--------------------------------

### Automation API Overview

Source: https://quip.com/dev/automation/documentation/current/index

This section provides an overview of the Quip Automation API, its core concepts, license requirements, VPC customer considerations, and rate limits.

```APIDOC
## Automation API (Current)

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:
  * _https://platform.acme.onquip.com/1/threads/edit-document_ or
  * _https://platform.quip-acme.com/1/threads/edit-document_

### 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
```

--------------------------------

### Add Kanban Board Live App to Quip Document

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Provides an example of adding a Kanban Board live app to a Quip document. It defines columns with headers and cards, including color coding and content.

```html
<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>
```

--------------------------------

### GET /1/folders/{id}

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Retrieves the details of a specific folder by its ID. This endpoint allows you to get information about a folder, and you can find your desktop or archive folder ID by using the Get Authenticated User operation.

```APIDOC
## GET /1/folders/{id}

### Description
Returns the given folder.

To find your desktop or archive folder ID, see [Get Authenticated User](#operation/getUser).

### Method
GET

### Endpoint
/1/folders/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - ID of the folder whose information you want to get.

#### Query Parameters
- **folder_include_chats** (string) - Optional - Specifies whether to include chat information in the response.

### Response
#### Success Response (200)
- **folder_info** - Schema describing the folder information.

#### Response Example
```json
{
  "example": "folder_info_response"
}
```
```

--------------------------------

### GET /1/oauth/login

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Redirect end users to this URL to get an OAuth 2.0 verification code.

```APIDOC
## GET /1/oauth/login

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

### Method
GET

### Endpoint
/1/oauth/login

### Parameters
#### Query Parameters
- **client_id** (string) - Required - The client ID you created for your application.
- **client_secret** (string) - Required - The client secret you created for your application.
- **redirect_uri** (string) - Required - The URL we should redirect back to with the verification code.
- **state** (integer) - Optional - If given, we include this argument in our redirect back to the `redirect_uri`. This is recommended to prevent a variety of security issues.

### Response
#### Success Response (302)
- **Location** (string) - The URL to redirect to. Same as the URL returned in the body.

#### Response Example
```
HTTP/1.1 302 Found
Location: https://quip.com/oauth/authorize?response_type=code&state=1234&redirect_uri=https%3A%2F%2Fapp.postman.com%2Foauth2%2Fcallback&client_id=YOUR_CLIENT_ID&scope=offline
```
```

--------------------------------

### API Versioning Example Scenario

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Illustrates how to update integrations to point to newer API versions when older versions are deprecated. This ensures continued access to API functionality.

```text
GET https://platform.quip.com/1/admin/sampleresource
GET https://platform.quip.com/2/admin/sampleresource
```

--------------------------------

### Example Thread JSON Response

Source: https://quip.com/dev/automation/documentation/current/index

Illustrates a typical JSON response for a Quip thread, including details about the thread itself, associated user IDs, shared folders, and access levels.

```json
{
  "thread": {
    "id": "AVN9AAeqq5w",
    "author_id": "LJa9EAtQi98",
    "owning_company_id": "IMbAcASGu56",
    "thread_class": "document",
    "created_usec": 1519926805974011,
    "updated_usec": 1558224928731511,
    "title": "❗️ very important cat pics ❗️",
    "link": "https://corp.quip.com/klUsAqWxr8Ne",
    "type": "document",
    "is_deleted": false,
    "is_template": false,
    "document_id": "KSRABARYWW9"
  },
  "user_ids": [
    "UTUAEAiZl6B"
  ],
  "shared_folder_ids": [
    "RKa9OAiGmsC"
  ],
  "expanded_user_ids": [
    "PZF9EA0i0ef",
    "dHe9EABHRsb",
    "EHY9EAokwO3"
  ],
  "invited_user_emails": [],
  "access_levels": {
    "PZF9EA0i0ef": {
      "access_level": "OWN"
    },
    "dHe9EABHRsb": {
      "access_level": "VIEW"
    },
    "EHY9EAokwO3": {
      "access_level": "EDIT"
    }
  },
  "html": "..."
}
```

--------------------------------

### GET /folders

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Retrieves folders, with a bulk variant of the Get Folder endpoint. Returns an object mapping IDs to folder objects.

```APIDOC
## GET /folders

### Description
Retrieves folders, with a bulk variant of the Get Folder endpoint. Returns an object mapping IDs to folder objects.

### Method
GET

### Endpoint
/folders

### Parameters
#### Query Parameters
- **ids** (string) - Required - A comma-separated list of folder IDs.
- **include_chats** (boolean) - Optional - If true, include the chat for each folder.

### Response
#### Success Response (200)
- **folder_id** (object) - Contains folder information.

#### Response Example
{
  "example": "{\"BULAOADdLWL\": {\"id\": \"BULAOADdLWL\", \"title\": \"Folder One\", \"thread_id\": \"TULAOADdLWL\"}}"
}
```

--------------------------------

### Get Recent Messages

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Use the Get Recent Messages API method to retrieve the 25 most-recent comments in a Quip document.

```APIDOC
## GET /api/messages/recent

### Description
Retrieves the 25 most-recent comments from a Quip document.

### Method
GET

### Endpoint
https://quip.com/dev/automation/documentation/current#operation/getRecentMessages

### Parameters
(No specific parameters mentioned in the text)

### Request Example
(No request example provided)

### Response
- **messages** (array) - An array containing the 25 most recent comments.

### Response Example
{
  "messages": [
    {
      "user_id": "user123",
      "timestamp": 1678886400,
      "text": "This is a comment."
    }
  ]
}
```

--------------------------------

### POST /1/folders/new

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Creates a new folder in Quip.

```APIDOC
## POST /1/folders/new

### Description
Creates a folder.

### Method
POST

### Endpoint
/1/folders/new

### Parameters
#### Request Body
- **title** (string) - Required - The name of the folder.
- **color** (string) - Optional - The color of the folder. Enum: manila, red, orange, green, blue, purple, dark_yellow, light_red, light_orange, light_green, light_blue, light_purple. Defaults to manila.
- **member_ids** (string) - Optional - A comma-separated list of user IDs to add as members of this folder.
- **parent_id** (string) - Optional - If given, makes the folder a child of the given folder. If not given, creates the folder in the authenticated user's Private folder.

### Response
#### Success Response (200)
- **folder_info** (object) - Contains information about the created folder.

#### Response Example
{
  "example": "{\"id\": \"BULAOADdLWL\", \"title\": \"New Folder\", \"thread_id\": \"TULAOADdLWL\", \"color\": \"manila\"}"
}
```

--------------------------------

### GET /1/threads/recent

Source: https://quip.com/dev/automation/documentation/current/openapi-specs

Retrieves the most recently updated threads, similar to the updates view in the Quip application. Results are returned in the same format as the 'Get Thread' operation.

```APIDOC
## GET /1/threads/recent

### Description
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](#operation/getThread).

### Method
GET

### Endpoint
/1/threads/recent

### Parameters
#### Query Parameters
- **count** (integer) - Optional - The number of threads to return. Defaults to 10. Minimum 1, Maximum 50.
- **max_updated_usec** (integer) - Optional - UNIX epoch timestamp. Searches only for threads that were last updated after this time.

### Request Example
`/1/threads/recent?count=20&max_updated_usec=1678886400`

### Response
#### Success Response (200)
*(The response format is the same as the Get Thread operation. Specific fields depend on that schema.)*

#### Response Example
*(Refer to the Get Thread operation's response example for structure.)*
```

--------------------------------

### Quip Folder Link Sharing Settings Response (JSON Example)

Source: https://quip.com/dev/automation/documentation/current/index

Illustrates the JSON output for the link sharing settings of a Quip folder. It indicates whether link sharing is enabled and if external access is permitted.

```json
[
  {
    "link_sharing_enabled": true,
    "external_access_allowed": false
}

]
```
Tokens:
Raw