box-curl-samples

KO | EN

gitlite — search

#javascript #python #hacktoberfest #react #ai #typescript #llm #go #golang #android #machine-learning #rust #deep-learning #linux

box-curl-samples

★ 20 Open GitHub ↗

A collection of cURL samples for the Box API.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Box cURL samples

## Authorize a user

Authorize a user by sending them through the [Box](https://box.com)
website and request their permission to act on their behalf.

This is the first step when authenticating a user using
OAuth 2.0. To request a user's authorization to use the Box APIs
on their behalf you will need to send a user to the URL with this
format.

```bash
curl -i -X GET "https://account.box.com/api/oauth2/authorize?response_type=code&client_id=ly1nj6n11vionaie65emwzk575hnnmrk&redirect_uri=http://example.com/auth/callback"
```

## Request an access token

Request an Access Token using either a client-side obtained OAuth2
authorization code or a server-side JWT assertion.

An Access Token is a string that enables Box to verify that a
request belongs to an authorized session. In the normal order of
operations you will begin by requesting authentication from the
[authorize](#get-authorize) endpoint and Box will send you an
authorization code.

You will then send this code to this endpoint to exchange it for
an Access Token. The returned Access Token can then be used to to make
Box API calls.

```bash
curl -i -X POST "https://api.box.com/oauth2/token" \
     -H "content-type: application/x-www-form-urlencoded" \
     -d "client_id=[CLIENT_ID]" \
     -d "client_secret=[CLIENT_SECRET]" \
     -d "code=[CODE]" \
     -d "grant_type=authorization_code"
```

## Refresh an access token

```bash
curl -i -X POST "https://api.box.com/oauth2/token" \
     -H "content-type: application/x-www-form-urlencoded" \
     -d "client_id=[CLIENT_ID]" \
     -d "client_secret=[CLIENT_SECRET]" \
     -d "refresh_token=[REFRESH_TOKEN]" \
     -d "grant_type=refresh_token"
```

## Downscope a token

```bash
curl -i -X POST "https://api.box.com/oauth2/token" \
     -H "content-type: application/x-www-form-urlencoded" \
     -d "subject_token=[ACCESS_TOKEN]" \
     -d "subject_token_type=urn:ietf:params:oauth:token-type:access_token" \
     -d "scope=item_upload item_preview base_explorer" \
     -d "resource=https://api.box.com/2.0/folders/123456" \
     -d "grant_type=urn:ietf:params:oauth:grant-type:token-exchange"
```

## Revoke an access token

Revoke an active Access Token, effectively logging a user out
that has been previously authenticated.

```bash
curl -i -X POST "https://api.box.com/oauth2/revoke" \
     -H "content-type: application/x-www-form-urlencoded" \
     -d "client_id=[CLIENT_ID]" \
     -d "client_secret=[CLIENT_SECRET]" \
     -d "token=[ACCESS_TOKEN]"
```

## Authentication with Client Credentials

Creates a token using Client Credentials Grant, which
allows you to log in as a Service Account.

```bash
curl -i -X POST "https://api.box.com/oauth2/token" \
     -H "content-type: application/x-www-form-urlencoded" \
     -d "client_id=[CLIENT_ID]" \
     -d "client_secret=[CLIENT_SECRET]" \
     -d "grant_type=client_credentials" \
     -d "box_subject_type=enterprise"  \
     -d "box_subject_id=[ENTERPRISE_ID]"
```

## Authentication with CCG as an admin or managed user

Creates a token using Client Credentials Grant, which
allows you to log in as an admin or a managed user.

```bash
curl -i -X POST "https://api.box.com/oauth2/token" \
     -H "content-type: application/x-www-form-urlencoded" \
     -d "client_id=[CLIENT_ID]" \
     -d "client_secret=[CLIENT_SECRET]" \
     -d "grant_type=client_credentials" \
     -d "box_subject_type=user"  \
     -d "box_subject_id=[USER_ID]"
```

## Authentication with CCG as app user

Creates a token using Client Credentials Grant, which
allows you to log in as any app user.

```bash
curl -i -X POST "https://api.box.com/oauth2/token" \
     -H "content-type: application/x-www-form-urlencoded" \
     -d "client_id=[CLIENT_ID]" \
     -d "client_secret=[CLIENT_SECRET]" \
     -d "grant_type=client_credentials" \
     -d "box_subject_type=user"  \
     -d "box_subject_id=[APPUSER_ID]"
```

## Send request to AI

## Send request to AI (extended)

```bash
curl -i -L -X POST "https://api.box.com/2.0/ai/ask" \
     -H "content-type: application/json" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
         "mode": "single_item_qa",
         "prompt": "What is the value provided by public APIs based on this document?",
         "items": [
        {
            "type": "file",
            "id": "9842787262"
        }
       ],
       "dialogue_history": [
        {
            "prompt": "Make my email about public APIs sound more professional",
            "answer": "Here is the first draft of your professional email about public APIs",
            "created_at": "2013-12-12T10:53:43-08:00"
        }
      ],
       "include_citations": true,
          "ai_agent": {
            "type": "ai_agent_ask",
            "long_text": {
              "model": "azure__openai__gpt_4o_mini",
              "system_message": "You are a helpful travel assistant specialized in budget travel",
              "prompt_template": "It is `{current_date}`, and I have $8000 and want to spend a week in the Azores. What should I see?",
              "num_tokens_for_completion": 8400,
              "llm_endpoint_params": {
                "type": "openai_params",
                "temperature": 0.0,
                "top_p": 1.0,
                "frequency_penalty": 1.5,
                "presence_penalty": 1.5,
                "stop": "<|im_end|>"
              },
              "embeddings": {
                "model": "openai__text_embedding_ada_002",
                "strategy": {
                  "id": "basic",
                  "num_tokens_per_chunk": 8400
                }
              }
            },
            "basic_text": {
              "model": "azure__openai__gpt_4o_mini",
              "system_message": "You are a helpful travel assistant specialized in budget travel",
              "prompt_template": "It is `{current_date}`, and I have $8000 and want to spend a week in the Azores. What should I see?",
              "num_tokens_for_completion": 8400,
              "llm_endpoint_params": {
                "type": "openai_params",
                "temperature": 0.0,
                "top_p": 1.0,
                "frequency_penalty": 1.5,
                "presence_penalty": 1.5,
                "stop": "<|im_end|>"
              }
            },
              "long_text_multi": {
                "model": "azure__openai__gpt_4o_mini",
                "system_message": "You are a helpful travel assistant specialized in budget travel",
                "prompt_template": "It is `{current_date}`, and I have $8000 and want to spend a week in the Azores. What should I see?",
                "num_tokens_for_completion": 8400,
                "llm_endpoint_params": {
                  "type": "openai_params",
                  "temperature": 0.0,
                  "top_p": 1.0,
                  "frequency_penalty": 1.5,
                  "presence_penalty": 1.5,
                  "stop": "<|im_end|>"
                },
                "embeddings": {
                  "model": "openai__text_embedding_ada_002",
                  "strategy": {
                    "id": "basic",
                    "num_tokens_per_chunk": 8400
                  }
                }
              },
              "basic_text_multi": {
                "model": "azure__openai__gpt_4o_mini",
                "system_message": "You are a helpful travel assistant specialized in budget travel",
                "prompt_template": "It is `{current_date}`, and I have $8000 and want to spend a week in the Azores. What should I see?",
                "num_tokens_for_completion": 8400,
                  "llm_endpoint_params": {
                    "type": "openai_params",
                    "temperature": 0.0,
                    "top_p": 1.0,
                    "frequency_penalty": 1.5,
                    "presence_penalty": 1.5,
                    "stop": "<|im_end|>"
              }
          }
      }'
```

## Send text generation request to AI

## Send text generation request to AI (extended)

```bash
curl -i -L -X POST "https://api.box.com/2.0/ai/text_gen" \
     -H "content-type: application/json" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
          "prompt": "Write a social media post about protein powder.",
          "items": [
         {
            "id": "12345678",
            "type": "file",
            "content": "More information about protein powders"
        }
        ],
          "dialogue_history": [
            {
                "prompt": "Make my email about public APIs sound more professional",
                "answer": "Here is the first draft of your professional email about public APIs",
                "created_at": "2013-12-12T10:53:43-08:00"
            },
            {
                "prompt": "Can you add some more information?",
                "answer": "Public API schemas provide necessary information to integrate with APIs...",
                "created_at": "2013-12-12T11:20:43-08:00"
            }
        ],
          "ai_agent": {
            "type": "ai_agent_text_gen",
            "basic_gen": {
              "model": "azure__openai__gpt_4o_mini",
              "system_message": "You are a helpful travel assistant specialized in budget travel",
              "prompt_template": "It is `{current_date}`, and I have $8000 and want to spend a week in Azores. What should I see?",
              "num_tokens_for_completion": 8400,
              "llm_endpoint_params": {
                "type": "openai_params",
                "temperature": 2.0,
                "top_p": 1.0,
                "frequency_penalty": 1.5,
                "presence_penalty": 1.5,
                "stop": "<|im_end|>"
              },
              "embeddings": {
                "model": "openai__text_embedding_ada_002",
                "strategy": {
                  "id": "basic",
                  "num_tokens_per_chunk": 64
                }
              },
              "content_template": "---{content}---"
           }
        }
     }'
```

## Get default agent config

```bash
curl -L -X GET "https://api.box.com/2.0/ai_agent_default?mode=text_gen" \
     -H 'Authorization: Bearer <ACCESS_TOKEN>'
```

## Create agents

Creates custom AI agents. At least one of the following capabilities
must be provided: `ask`, `text_gen`, `extract`.

```bash
curl -i -L -X POST "https://api.box.com/2.0/ai_agents" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "type": "ai_agent",
       "name": "My AI Agent",
       "access_state": "enabled",
       "ask": {
         "type": "ai_agent_ask",
         "access_state": "enabled",
         "description": "Answers questions about documents"
       }
     }'
```

## Delete AI agent

```bash
curl -L -X DELETE "https://api.box.com/2.0/ai_agents/12345" \
      -H 'Authorization: Bearer <ACCESS_TOKEN>'
```

## Get AI agent by ID

```bash
curl -i -X GET "https://api.box.com/2.0/ai_agents/1234567890" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get AI agents

```bash
curl -i -X GET "https://api.box.com/2.0/ai_agents" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update AI agents

```bash
curl -i -X PUT "https://api.box.com/2.0/ai_agents/1234567890" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Extract structured metadata

## Extract structured metadata (extended)

```bash
curl -i -L 'https://api.box.com/2.0/ai/extract_structured' \
     -H 'content-type: application/json' \
     -H 'authorization: Bearer <ACCESS_TOKEN>' \
     -d '{
        "items": [
          {
            "id": "12345678",
            "type": "file",
            "content": "This is file content."
          }
        ],
        "metadata_template": {
            "template_key": "",
            "type": "metadata_template",
            "scope": ""
        },
        "fields": [
            {
              "key": "name",
              "description": "The name of the person.",
              "displayName": "Name",
              "prompt": "The name is the first and last name from the email address.",
              "type": "string",
              "options": [
                {
                  "key": "First Name"
                },
                {
                  "key": "Last Name"
                }
              ]
            }
        ],
        "ai_agent": {
          "type": "ai_agent_extract_structured",
          "long_text": {
            "model": "azure__openai__gpt_4o_mini",
            "system_message": "You are a helpful travel assistant specialized in budget travel",
            "prompt_template": "It is `{current_date}`, and I have $8000 and want to spend a week in the Azores. What should I see?",
            "num_tokens_for_completion": 8400,
            "llm_endpoint_params": {
              "type": "openai_params",
              "temperature": 0,
              "top_p": 1,
              "frequency_penalty": 1.5,
              "presence_penalty": 1.5,
              "stop": "<|im_end|>"
            },
            "embeddings": {
              "model": "openai__text_embedding_ada_002",
              "strategy": {
                "id": "basic",
                "num_tokens_per_chunk": 64
              }
            }
          },
          "basic_text": {
            "model": "azure__openai__gpt_4o_mini",
            "system_message": "You are a helpful travel assistant specialized in budget travel",
            "prompt_template": "It is `{current_date}`, and I have $8000 and want to spend a week in the Azores. What should I see?",
            "num_tokens_for_completion": 8400,
            "llm_endpoint_params": {
              "type": "openai_params",
              "temperature": 0,
              "top_p": 1,
              "frequency_penalty": 1.5,
              "presence_penalty": 1.5,
              "stop": "<|im_end|>"
            }
          }
        }
    }'
```

## Extract metadata

## Extract metadata (extended)

```bash
curl -i -L 'https://api.box.com/2.0/ai/extract' \
     -H 'content-type: application/json' \
     -H 'authorization: Bearer <ACCESS_TOKEN>' \
     -d '{
        "prompt": "Extract data related to contract conditions",
        "items": [
              {
                  "type": "file",
                  "id": "1497741268097"
              }
        ],
        "ai_agent": {
          "type": "ai_agent_extract",
          "long_text": {
            "model": "azure__openai__gpt_4o_mini",
            "system_message": "You are a helpful travel assistant specialized in budget travel",
            "prompt_template": "It is `{current_date}`, and I have $8000 and want to spend a week in the Azores. What should I see?",
            "num_tokens_for_completion": 8400,
            "llm_endpoint_params": {
              "type": "openai_params",
              "temperature": 0,
              "top_p": 1,
              "frequency_penalty": 1.5,
              "presence_penalty": 1.5,
              "stop": "<|im_end|>"
            },
            "embeddings": {
              "model": "openai__text_embedding_ada_002",
              "strategy": {
                "id": "basic",
                "num_tokens_per_chunk": 64
              }
            }
          },
          "basic_text": {
            "model": "azure__openai__gpt_4o_mini",
            "system_message": "You are a helpful travel assistant specialized in budget travel",
            "prompt_template": "It is `{current_date}`, and I have $8000 and want to spend a week in the Azores. What should I see?",
            "num_tokens_for_completion": 8400,
            "llm_endpoint_params": {
              "type": "openai_params",
              "temperature": 0,
              "top_p": 1,
              "frequency_penalty": 1.5,
              "presence_penalty": 1.5,
              "stop": "<|im_end|>"
            }
          }
        }
      }'
```

## Add a Doc Gen template

```bash
curl -L 'https://api.box.com/2.0/docgen_templates' \
     -H 'box-version: 2025.0' \
     -H 'Authorization: Bearer <ACCESS_TOKEN>' \
     -H 'Content-Type: application/json' \
     -D '{
        "file": {
            "id": "12345678",
            "type": "file"
        }
}'
```

## Delete association between Doc Gen template and file

```bash
curl -L -X DELETE 'https://api.box.com/2.0/docgen_templates/12345678' \
     -H 'box-version: 2025.0' \
     -H 'Authorization: Bearer <ACCESS_TOKEN>'
```

## Get all Doc Gen templates

```bash
curl -L 'https://api.box.com/2.0/docgen_templates' \
     -H 'box-version: 2025.0' \
     -H 'Authorization: Bearer <ACCESS_TOKEN>'
```

## Get Doc Gen template by ID

```bash
curl -L 'https://api.box.com/2.0/docgen_templates/12345678' \
     -H 'box-version: 2025.0' \
     -H 'Authorization: Bearer <ACCESS_TOKEN>'
```

## Get Doc Gen jobs for a template

```bash
curl -L 'https://api.box.com/2.0/docgen_template_jobs/12345678' \
     -H 'box-version: 2025.0' \
     -H 'Authorization: Bearer <ACCESS_TOKEN>'
```

## Get Doc Gen template tags for template

```bash
curl -L 'https://api.box.com/2.0/docgen_templates/12345678/tags' \
     -H 'box-version: 2025.0' \
     -H 'Authorization: Bearer <ACCESS_TOKEN>'
```

## Generate a document with Doc Gen

```bash
curl -L 'https://api.box.com/2.0/docgen_batches' \
     -H 'box-version: 2025.0' \
     -H 'Authorization: Bearer <ACCESS_TOKEN>' \
     -D '{
        "file": {
            "id": "12345678",
            "type": "file"
        },
        "input_source": "api",
        "destination_folder": {
            "id": "12345678",
            "type": "folder"
        },
        "output_type": "docx",
        "document_generation_data": [
            {
                "generated_file_name": "Image test",
                "user_input": {
                    "order": {
                        "id": "12305",
                        "date": "18-08-2023",
                        "country": "US",
                        "expiryDate": "18-08-2024",
                        "currency": "$",
                        "amount": 5060.5,
                        "taxRate": 10,
                        "requester": "John",
                        "approver": "Smith",
                        "department": "Procurement",
                        "paymentTerms": "30 days",
                        "deliveryTerms": "30 days",
                        "deliveryDate": "18-09-2023",
                        "vendor": {
                            "company": "Example company",
                            "address": {
                                "street": "Example street",
                                "city": "Example city",
                                "zip": "EX-456"
                            }
                        },
                        "products": [
                            {
                                "id": 1,
                                "name": "A4 Papers",
                                "type": "non-fragile",
                                "quantity": 100,
                                "price": 29,
                                "amount": 2900
                            },
                            {
                                "id": 2,
                                "name": "Ink  Cartridge",
                                "type": "non-fragile",
                                "quantity": 40,
                                "price": 39,
                                "amount": 1560
                            },
                            {
                                "id": 3,
                                "name": "Adhesive tape",
                                "type": "non-fragile",
                                "quantity": 20,
                                "price": 30,
                                "amount": 600.5
                            }
                        ]
                    }
                }
            }
        ]`

```

## Get all Doc Gen jobs

```bash
curl -i -X GET "https://api.box.com/2.0/docgen_jobs" \
     -H 'box-version: 2025.0' \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get Doc Gen job by ID

```bash
curl -i -X GET "https://api.box.com/2.0/docgen_jobs/12345" \
     -H 'box-version: 2025.0' \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get Doc Gen job for a specific batch

```bash
curl -i -X GET "https://api.box.com/2.0/docgen_batch_jobs/12345" \
     -H 'box-version: 2025.0' \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get a file

Retrieves the details about a file.

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Restore file

Restores an file that has been moved to the trash.

```bash
curl -i -X POST "https://api.box.com/2.0/files/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update a file

Updates a file. This can be used to rename or move a file,
create a shared link, or lock a file.

```bash
curl -i -X PUT "https://api.box.com/2.0/files/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "name": "New name"
     }'
```

## Delete a file

Deletes a file, either permanently or by moving it to
the trash.

The the enterprise settings determine whether the item will
be permanently deleted from Box or moved to the trash.

```bash
curl -i -X DELETE "https://api.box.com/2.0/files/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Download a file

Returns the contents of a file in binary format.

```bash
curl -i -L -X GET "https://api.box.com/2.0/files/12345/content" \
     -H "authorization: Bearer <ACCESS_TOKEN>" 
```

## Download a file version

```bash
curl -i -L -X GET "https://api.box.com/2.0/files/12345/content?version=4" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get download URL

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345/content?version=4" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Download a shared link

Returns the contents of a file in binary format.

```bash
curl -i -L -X GET "https://api.box.com/2.0/files/12345/content" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "boxapi: shared_link=https://cloud.box.com/shared/static/gjasdasjhasd&shared_link_password=letmein"
```

## Upload a file version

Update a file's content. For file sizes over 50MB we recommend
using the Chunk Upload APIs.

```bash
curl -i -X POST "https://upload.box.com/api/2.0/files/12345/content" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: multipart/form-data" \
     -F attributes='{"name":"Contract.pdf", "parent":{"id":"11446498"}}' \
     -F file=@<FILE_NAME>
```

## Preflight check

Performs a check to verify that a file will be accepted by Box
before you upload the entire file.

```bash
curl -i -X OPTIONS "https://api.box.com/2.0/files/content" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{"name":"Contract.pdf", "parent":{"id":"11446498"}}'
```

```bash
curl -i -X OPTIONS "https://api.box.com/2.0/files/12345/content" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{"name":"Contract.pdf", "parent":{"id":"11446498"}}'
```

## Upload a file

Uploads a small file to Box. For file sizes over 50MB we recommend
using the Chunk Upload APIs.

```bash
curl -i -X POST "https://upload.box.com/api/2.0/files/content" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: multipart/form-data" \
     -F attributes='{"name":"Contract.pdf", "parent":{"id":"11446498"}}' \
     -F file=@<FILE_NAME>
```

## Create upload session

Creates an upload session for a new file.

```bash
curl -i -X POST "https://upload.box.com/api/2.0/files/upload_sessions" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "folder_id": "0",
       "file_size": 104857600,
       "file_name": "Contract.pdf"
     }'
```

## Create upload session for existing file

Creates an upload session for an existing file.

```bash
curl -i -X POST "https://upload.box.com/api/2.0/files/12345/upload_sessions" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "file_size": 104857600
     }'
```

## Get upload session

Return information about an upload session.

```bash
curl -i -X GET "https://upload.box.com/api/2.0/files/upload_sessions/F971964745A5CD0C001BBE4E58196BFD" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Upload a part

Updates a chunk of an upload session for a file.

```bash
curl -i -X PUT "https://upload.box.com/api/2.0/files/upload_sessions/F971964745A5CD0C001BBE4E58196BFD" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "digest: sha=fpRyg5eVQletdZqEKaFlqwBXJzM=" \
     -H "content-range: bytes 8388608-16777215/445856194" \
     -H "content-type: application/octet-stream" \
     --data-binary @<FILE_NAME>
```

## Abort upload session

Abort an upload session and discard all data uploaded.

This cannot be reversed.

```bash
curl -i -X DELETE "https://upload.box.com/api/2.0/files/upload_sessions/F971964745A5CD0C001BBE4E58196BFD" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List parts

Return a list of the chunks uploaded to the upload
session so far.

```bash
curl -i -X GET "https://upload.box.com/api/2.0/files/upload_sessions/F971964745A5CD0C001BBE4E58196BFD/parts" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Commit upload session

Close an upload session and create a file from the
uploaded chunks.

```bash
curl -i -X POST "https://upload.box.com/api/2.0/files/upload_sessions/F971964745A5CD0C001BBE4E58196BFD/commit" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "digest: sha=fpRyg5eVQletdZqEKaFlqwBXJzM=" \
     -H "content-type: application/json" \
     -d '{
       "parts": [
         {
           "part_id": "BFDF5379",
           "offset": 0,
           "size": 8388608,
	     "sha1": "134b65991ed521fcfe4724b7d814ab8ded5185dc"
         },
		     {
           "part_id": "E8A3ED8E",
           "offset": 8388608,
           "size": 1611392,
	     "sha1": "234b65934ed521fcfe3424b7d814ab8ded5185dc"
         }
       ],
       "attributes": {
         "content_modified_at": "2017-04-08T00:58:08Z"
       }
     }'
```

## Copy a file

Creates a copy of a file.

```bash
curl -i -X POST "https://api.box.com/2.0/files/12345/copy" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "parent": {
         "id": "123"
       }
     }'
```

## Get a file thumbnail

Retrieves a thumbnail, or smaller image representation, of a file.

Sizes of `32x32`,`64x64`, `128x128`, and `256x256` can be returned in
the `.png` format and sizes of `32x32`, `94x94`, `160x160`, and `320x320`
can be returned in the `.jpg` format.

Thumbnails can be generated for the image and video file formats listed
[found on our community site](http://community.box.com/t5/Managing-
Your-Content/What-file-types-are-supported-by-Box-s-Content-Preview/
ta-p/327).

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345/thumbnail.png" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get file collaborations

Retrieves a list of collaborations for a file. This
returns all the users that have access to the file.

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345/collaborations" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List a file's comments

Retrieves a list of comments for a file.

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345/comments" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get file tasks

Retrieves a list of all the tasks for a file. This
endpoint does not support paging.

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345/tasks" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get trashed file

Retrieves a file that has been moved to the trash.

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345/trash" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Permanently delete file

Permanently deletes a file that is in the trash.
This action cannot be undone.

```bash
curl -i -X DELETE "https://api.box.com/2.0/files/12345/trash" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List all file versions

Retrieve information on all version of a file. This endpoint can be used to
retrieve information about older versions of a file.

Versions are only tracked for Box users with premium accounts.

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345/versions" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get a file version

Retrieve a specific older version of a file.

Versions are only tracked for Box users with premium accounts.

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345/versions/456456" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Delete file version

Move a file version to the trash.

Versions are only tracked for Box users with premium accounts.

```bash
curl -i -X DELETE "https://api.box.com/2.0/files/12345/versions/456456" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Promote file version

Promote a specific version of a file.

If previous versions exist, this method can be used to
promote one of the older versions to the top of the version history.

This actually creates a new copy of the old version and puts it at the
top of the versions history. The file will have the exact same contents
as the older version, with the the same SHA1/etag, and the same name
as the original.

Other properties such as comments do not get updated to their
former values.
Don't use this endpoint to restore Box Notes,
as it works with file formats such as PDF, DOC, PPTX or similar.

```bash
curl -i -X POST "https://api.box.com/2.0/files/12345/versions/current" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "type": "file_version",
       "id": "456456"
     }'
```

## Restore file version

Restores a specific version of a file after it was deleted.
Don't use this endpoint to restore Box Notes,
as it works with file formats such as PDF, DOC, PPTX or similar.

```bash
curl -i -X PUT "https://api.box.com/2.0/files/12345/versions/456456" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "trashed_at": null
     }'
```

## List file's metadata

Retrieves all metadata for a given file.

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345/metadata" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get specific file metadata

Retrieve a specific metadata template instance for a file

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345/metadata/enterprise_27335/blueprintTemplate" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create metadata on file

Creates a piece of metadata on a file based on the specified template.

Only values that are present in the metadata template
will be accepted.

```bash
curl -i -X POST "https://api.box.com/2.0/files/12345/metadata/enterprise_27335/blueprintTemplate" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "audience": "internal",
       "documentType": "Q1 plans",
       "competitiveDocument": "no",
       "status": "active",
       "author": "Jones",
       "currentState": "proposal"
     }'

```

## Update file metadata

Updates a piece of metadata on a file.

The metadata instance can only be updated if the instance
already exists. When editing metadata, only values that adhere to the
metadata template schema will be accepted.

The update is applied atomically. If any errors occur during the
application of the operations, the metadata instance remains unchanged.

```bash
curl -i -X PUT "https://api.box.com/2.0/files/12345/metadata/enterprise_27335/blueprintTemplate" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json-patch+json" \
     -d '[
        {
          "op": "test",
          "path": "/competitiveDocument",
          "value": "no"
        },
        {
          "op": "remove",
          "path": "/competitiveDocument"
        },
        {
          "op": "test",
          "path": "/status",
          "value": "active"
        },
        {
          "op": "replace",
          "path": "/status",
          "value": "inactive"
        },
        {
          "op": "test",
          "path": "/author",
          "value": "Jones"
        },
        {
          "op": "copy",
          "from": "/author",
          "path": "/editor"
        },
        {
          "op": "test",
          "path": "/currentState",
          "value": "proposal"
        },
        {
          "op": "move",
          "from": "/currentState",
          "path": "/previousState"
        },
        {
          "op": "add",
          "path": "/currentState",
          "value": "reviewed"
        }
      ]'
```

## Delete file metadata

Deletes a piece of file metadata.

```bash
curl -i -X DELETE "https://api.box.com/2.0/files/12345/metadata/enterprise_27335/blueprintTemplate" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get file watermark

Retrieve the watermark for a file.

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345/watermark" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Apply watermark to file

Applies or update a watermark on a file.

```bash
curl -i -X PUT "https://api.box.com/2.0/files/12345/watermark" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "watermark": {
         "imprint": "default"
       }
     }'
```

## Remove file watermark

Removes the watermark from a file.

```bash
curl -i -X DELETE "https://api.box.com/2.0/files/12345/watermark" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get a folder

Retrieves details for a folder, including the first 100 entries
in the folder.

To fetch more items within the folder, please use the
[Get items in a folder](#get-folders-id-items) endpoint.

```bash
curl -i -X GET "https://api.box.com/2.0/folders/4353455" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Restore folder

Restores a folder that has been moved to the trash.

```bash
curl -i -X POST "https://api.box.com/2.0/folders/4353455" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update a folder

Updates a folder. This can be also be used to move the folder,
create shared links, update collaborations, and more.

## Move a folder

```bash
curl -i -X PUT "https://api.box.com/2.0/folders/4353455" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "name": "New folder name",
       "parent": {
         "id": "123"
       }
     }'
```

## Move a subfolder to a private folder

## Rename a folder

## Change folder owner

```bash
curl -i -X PUT "https://api.box.com/2.0/folders/4353455" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "owned_by": {
         "id": "123"
       }
     }'
```

## Delete a folder

Deletes a folder, either permanently or by moving it to
the trash.

```bash
curl -i -X DELETE "https://api.box.com/2.0/folders/4353455" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get items in folder

Retrieves a page of items in a folder. These items can be files,
folders, and web links.

To request more information about the folder itself, like its size,
please use the [Get a folder](#get-folders-id) endpoint instead.

```bash
curl -i -X GET "https://api.box.com/2.0/folders/0/items" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create a folder

Creates a new empty folder within the specified parent folder.

```bash
curl -i -X POST "https://api.box.com/2.0/folders" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "name": "New Folder",
       "parent": {
         "id": "0"
       }
     }'
```

## Copy a folder

Creates a copy of a folder within a destination folder.

The original folder will not be changed.

```bash
curl -i -X POST "https://api.box.com/2.0/folders/4353455/copy" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "parent": {
         "id": "345345"
       }
     }'
```

## Get folder collaborations

Retrieves a list of collaborations for a folder. This
returns all the users that have access to the folder.

```bash
curl -i -X GET "https://api.box.com/2.0/folders/4353455/collaborations" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get trashed folder

Retrieves a folder that has been moved to the trash.

```bash
curl -i -X GET "https://api.box.com/2.0/folders/4353455/trash" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Permanently delete folder

Permanently deletes a folder that is in the trash.
This action cannot be undone.

```bash
curl -i -X DELETE "https://api.box.com/2.0/folders/4353455/trash" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List folder's metadata

Retrieves all metadata for a given folder.

```bash
curl -i -X GET "https://api.box.com/2.0/folders/4353455/metadata" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get specific folder metadata

Retrieve a specific metadata template instance for a folder

```bash
curl -i -X GET "https://api.box.com/2.0/folders/4353455/metadata/enterprise_27335/blueprintTemplate" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create metadata on folder

Creates a piece of metadata on a folder based on the specified template.

Only values that are present in the metadata template
will be accepted.

```bash
curl -i -X POST "https://api.box.com/2.0/folders/4353455/metadata/enterprise_27335/blueprintTemplate" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "audience": "internal",
       "documentType": "Q1 plans",
       "competitiveDocument": "no",
       "status": "active",
       "author": "Jones",
       "currentState": "proposal"
     }'
```

## Update folder metadata

Updates a piece of metadata on a folder based.

The metadata instance can only be updated if the instance
already exists. When editing metadata, only values that adhere to the
metadata template schema will be accepted.

The update is applied atomically. If any errors occur during the
application of the operations, the metadata instance remains unchanged.

```bash
curl -i -X PUT "https://api.box.com/2.0/folders/4353455/metadata/enterprise_27335/blueprintTemplate" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json-patch+json" \
     -d '[
        {
          "op": "test",
          "path": "/competitiveDocument",
          "value": "no"
        },
        {
          "op": "remove",
          "path": "/competitiveDocument"
        },
        {
          "op": "test",
          "path": "/status",
          "value": "active"
        },
        {
          "op": "replace",
          "path": "/status",
          "value": "inactive"
        },
        {
          "op": "test",
          "path": "/author",
          "value": "Jones"
        },
        {
          "op": "copy",
          "from": "/author",
          "path": "/editor"
        },
        {
          "op": "test",
          "path": "/currentState",
          "value": "proposal"
        },
        {
          "op": "move",
          "from": "/currentState",
          "path": "/previousState"
        },
        {
          "op": "add",
          "path": "/currentState",
          "value": "reviewed"
        }
      ]'
```

## Delete folder metadata

Deletes a piece of folder metadata.

```bash
curl -i -X DELETE "https://api.box.com/2.0/folders/4353455/metadata/enterprise_27335/blueprintTemplate" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List trashed items

Retrieves the files and folders that have been moved
to the trash.

Any attribute in the full files or folders objects can be passed
in with the `fields` parameter to retrieve those specific
attributes that are not returned by default.

```bash
curl -i -X GET "https://api.box.com/2.0/folders/trash/items" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get folder watermark

Retrieve the watermark for a folder.

```bash
curl -i -X GET "https://api.box.com/2.0/folders/4353455/watermark" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Apply watermark to folder

Applies or update a watermark on a folder.

```bash
curl -i -X PUT "https://api.box.com/2.0/folders/4353455/watermark" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "watermark": {
         "imprint": "default"
       }
     }'
```

## Remove folder watermark

Removes the watermark from a folder.

```bash
curl -i -X DELETE "https://api.box.com/2.0/folders/4353455/watermark" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get folder lock

Retrieve locks applied to a folder.

```bash
curl -i -X GET "https://api.box.com/2.0/folder_locks?folder_id=33552487093" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create folder lock

Creates a lock on a folder to prevent move and / or delete operations.

```bash
curl -i -X POST "https://api.box.com/2.0/folder_locks" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "folder": {
         "type": "folder",
         "id": "33552487093"
       },
       "locked_operations": {
         "move": true,
         "delete": true
       }
     }'
```

## Delete folder lock

Deletes a lock on a folder.

```bash
curl -i -X DELETE "https://api.box.com/2.0/folder_locks/93134" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get template by name

Retrieves a metadata template by its scope and template name.

```bash
curl -i -X GET "https://api.box.com/2.0/metadata_templates/enterprise/blueprintTemplate/schema" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update metadata template

Updates a metadata template.

The metadata template can only be updated if the template
already exists.

The update is applied atomically. If any errors occur during the
application of the operations, the metadata template remains unchanged.

```bash
curl -i -X PUT "https://api.box.com/2.0/metadata_templates/enterprise/blueprintTemplate/schema" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json-patch+json" \
     -d '[
       {
         "op": "editField",
         "fieldKey": "category",
         "data": {
           "displayName": "Customer Group"
         }
       }
     ]'
```

## Delete metadata template

Delete a metadata template and its instances.
This deletion is permanent and can not be reversed.

```bash
curl -i -X DELETE "https://api.box.com/2.0/metadata_templates/enterprise/blueprintTemplate/schema" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get a template by ID

Retrieves a metadata template by its ID.

```bash
curl -i -X GET "https://api.box.com/2.0/metadata_templates/d9671692-3df6-11ea-b77f-2e728ce88125" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List enterprise templates

Used to retrieve all metadata templates within a user's enterprise

```bash
curl -i -X GET "https://api.box.com/2.0/metadata_templates/enterprise" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List global templates

Used to retrieve all globally available metadata templates.

```bash
curl -i -X GET "https://api.box.com/2.0/metadata_templates/global" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create metadata template

Creates a new metadata template that can be applied to files and folders.

```bash
curl -i -X POST "https://api.box.com/2.0/metadata_templates/schema" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
      "scope": "enterprise",
      "displayName": "Customer",
      "fields": [
        {
          "type": "string",
          "key": "name",
          "displayName": "Name",
          "description": "The customer name",
          "hidden": false
        },
        {
          "type": "date",
          "key": "last_contacted_at",
          "displayName": "Last Contacted At",
          "description": "When this customer was last contacted at",
          "hidden": false
        },
        {
          "type": "enum",
          "key": "industry",
          "displayName": "Industry",
          "options": [
            {"key": "Technology"},
            {"key": "Healthcare"},
            {"key": "Legal"}
          ]
        },
        {
          "type": "multiSelect",
          "key": "role",
          "displayName": "Contact Role",
          "options": [
            {"key": "Developer"},
            {"key": "Business Owner"},
            {"key": "Marketing"},
            {"key": "Legal"},
            {"key": "Sales"}
          ]
        }
      ]
    }'
```

## List cascade policies

Retrieve a collection of metadata cascade policies
within a given folder for the current enterprise.

```bash
curl -i -X GET "https://api.box.com/2.0/metadata_cascade_policies?folder_id=31232" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create cascade policy

Creates a new metadata cascade policy that applies a given
metadata template to a given folder and automatically
cascades it down to its children.

In order for the policy to work, a metadata instance must first
be applied to the folder.

```bash
curl -i -X POST "https://api.box.com/2.0/metadata_cascade_policies" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "folder_id": "12321",
       "scope": "enterprise_27335",
       "templateKey": "productInfo"
     }'
```

## Get cascade policy

Retrieve a metadata cascade policy.

```bash
curl -i -X GET "https://api.box.com/2.0/metadata_cascade_policies/324324" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Delete cascade policy

Deletes a metadata cascade policy.

```bash
curl -i -X DELETE "https://api.box.com/2.0/metadata_cascade_policies/324324" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Force apply cascade policy

If a policy already exists on a folder, this will apply that policy
to all existing files and sub-folders within the target folder.

```bash
curl -i -X POST "https://api.box.com/2.0/metadata_cascade_policies/21312/apply" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "conflict_resolution": "overwrite"
     }'
```

## Create a metadata query

```bash
curl -i -X POST "https://api.box.com/2.0/metadata_queries/execute_read" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "from": "enterprise_123456.contractTemplate",
       "query": "amount >= :value",
       "query_params": {
         "value": 100
       },
       "fields": [
         "created_at",
         "metadata.enterprise_123456.contractTemplate.amount",
         "metadata.enterprise_123456.contractTemplate.customerName"
       ],
       "ancestor_folder_id": "5555",
       "order_by": [
         {
           "field_key": "amount",
           "direction": "asc"
         }
       ],
       "limit": 100
     }'
```

## Get metadata query indices

```bash
curl -i -X GET "https://api.box.com/2.0/metadata_query_indices?scope=enterprise&template_key=properties" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create metadata taxonomy

Creates a new metadata taxonomy that can be used in metadata templates.

```bash
curl -i -X POST "https://api.box.com/2.0/metadata_taxonomies" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "displayName": "Geography",
       "key": "geography",
       "namespace": "enterprise_123456"
     }'
```

## Get metadata taxonomies for namespace

Used to retrieve all metadata taxonomies in a namespace.

```bash
curl -i -X GET "https://api.box.com/2.0/metadata_taxonomies/enterprise_123456" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get metadata taxonomy by taxonomy key

Used to retrieve a metadata taxonomy by taxonomy key.

```bash
curl -i -X GET "https://api.box.com/2.0/metadata_taxonomies/enterprise_123456/geography" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Remove metadata taxonomy

Delete a metadata taxonomy. This deletion is permanent and cannot be
reverted.

```bash
curl -i -X DELETE "https://api.box.com/2.0/metadata_taxonomies/enterprise_123456/geography" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create metadata taxonomy levels

Creates new metadata taxonomy levels.

```bash
curl -i -X POST "https://api.box.com/2.0/metadata_taxonomies/enterprise_123456/geography/levels" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '[
       {
         "displayName": "Continent",
         "description": "Continent Level"
       },
       {
         "displayName": "Country",
         "description": "Country Level"
       }
     ]'
```

## Delete metadata taxonomy level

Deletes the last level of the metadata taxonomy.

```bash
curl -i -X POST "https://api.box.com/2.0/metadata_taxonomies/enterprise_123456/geography/levels:trim" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List metadata taxonomy nodes

Used to retrieve metadata taxonomy nodes based on the parameters
specified.

```bash
curl -i -X GET "https://api.box.com/2.0/metadata_taxonomies/enterprise_123456/geography/nodes" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create metadata taxonomy node

Creates a new metadata taxonomy node.

```bash
curl -i -X POST "https://api.box.com/2.0/metadata_taxonomies/enterprise_123456/geography/nodes" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "displayName": "Europe",
       "level": 1
     }'
```

## Get metadata taxonomy node by ID

Retrieves a metadata taxonomy node by its identifier.

```bash
curl -i -X GET "https://api.box.com/2.0/metadata_taxonomies/enterprise_123456/geography/nodes/14d3d433-c77f-49c5-b146-9dea370f6e32" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Remove metadata taxonomy node

Delete a metadata taxonomy node. This deletion is permanent and cannot
be reverted. Only metadata taxonomy nodes without any children can be
deleted.

```bash
curl -i -X DELETE "https://api.box.com/2.0/metadata_taxonomies/enterprise_123456/geography/nodes/14d3d433-c77f-49c5-b146-9dea370f6e32" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List metadata template's options for taxonomy field

Used to retrieve metadata taxonomy nodes which are available for the
taxonomy field based on its configuration and the parameters specified.

```bash
curl -i -X GET "https://api.box.com/2.0/metadata_templates/enterprise_123456/properties/fields/geography/options" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get comment

Retrieves the message and metadata for a specific comment, as well
as information on the user who created the comment.

```bash
curl -i -X GET "https://api.box.com/2.0/comments/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update comment

Update the message of a comment.

```bash
curl -i -X PUT "https://api.box.com/2.0/comments/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "message": "My New Message"
     }'
```

## Delete comment

Permanently deletes a comment.

```bash
curl -i -X DELETE "https://api.box.com/2.0/comments/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create comment

Adds a comment comment by the user to a specific file, or
as a reply to an other comment.

```bash
curl -i -X POST "https://api.box.com/2.0/comments" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "message": "Review completed!",
       "item": {
         "type": "file",
         "id": 426436
       }
     }'
```

## Create reply

```bash
curl -i -X POST "https://api.box.com/2.0/comments" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "message": "I agree with this.",
       "item": {
         "type": "comment",
         "id": 345344
       }
     }
```

## Tag User in Comment

```bash
curl -i -X POST "https://api.box.com/2.0/comments" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "tagged_message": "What do you think @[1234:John]?",
       "item": {
         "type": "file",
         "id": 123
       }
     }
```

## Tag User in Reply

```bash
curl -i -X POST "https://api.box.com/2.0/comments" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "message": " @[1234:John], I agree with this.",
       "item": {
         "type": "comment",
         "id": 345344
       }
     }
```

## Get collaboration

Retrieves a single collaboration.

```bash
curl -i -X GET "https://api.box.com/2.0/collaborations/1234" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update collaboration

Updates a collaboration.

Can be used to change the owner of an item, or to
accept collaboration invites.

```bash
curl -i -X PUT "https://api.box.com/2.0/collaborations/1234" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "role": "viewer"
     }'
```

## Delete collaboration

Deletes a single collaboration.

```bash
curl -i -X DELETE "https://api.box.com/2.0/collaborations/1234" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List pending collaborations

Retrieves all pending collaboration invites for this user.

```bash
curl -i -X GET "https://api.box.com/2.0/collaborations?status=pending" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create collaboration

Adds a collaboration for a single user or a single group to a file
or folder.

Collaborations can be created using email address, user IDs, or a
group IDs.

If a collaboration is being created with a group, access to
this endpoint is dependent on the group's ability to be invited.

```bash
curl -i -X POST "https://api.box.com/2.0/collaborations" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "item": {
         "type": "file",
         "id": "11446498"
       },
       "accessible_by": {
         "type": "user",
         "login": "user@example.com"
       },
       "role": "editor"
     }'
```

```bash
curl -i -X POST "https://api.box.com/2.0/collaborations" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "item": {
         "type": "file",
         "id": "11446498"
       },
       "accessible_by": {
         "type": "group",
         "id": "845344"
       },
       "role": "editor"
     }'
```

## Search for content

Searches for items that are available to the user or an entire enterprise.

```bash
curl -i -X GET "https://api.box.com/2.0/search?query=sales" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create task

Creates a single task on a file.

```bash
curl -i -X POST "https://api.box.com/2.0/tasks" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "item": {
         "id": "11446498",
         "type": "file"
       },
       "action": "review"
     }'
```

## Get task

Fetches a specific task.

```bash
curl -i -X GET "https://api.box.com/2.0/tasks/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update task

Updates a specific task.

```bash
curl -i -X PUT "https://api.box.com/2.0/tasks/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "action": "review"
     }'
```

## Delete task

Deletes a specific task.

```bash
curl -i -X DELETE "https://api.box.com/2.0/tasks/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List task's assignments

Retrieves all of the assignments for a given task.

```bash
curl -i -X GET "https://api.box.com/2.0/tasks/12345/assignments" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Assign task

Assigns a task to a user.

Multiple assignments to different users
are allowed per task.

```bash
curl -i -X POST "https://api.box.com/2.0/task_assignments" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "task": {
         "id": "11446498",
         "type": "task"
       },
       "assign_to": {
         "id": "4823213"
       }
     }'
```

## Get task assignment

Fetches a specific task assignment.

```bash
curl -i -X GET "https://api.box.com/2.0/task_assignments/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update task assignment

Updates a task assignment. This endpoint can be
used to update the state of a task.

```bash
curl -i -X PUT "https://api.box.com/2.0/task_assignments/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "message": "New message",
       "resolution_state": "completed"
     }'
```

## Unassign task

Deletes a specific task assignment.

```bash
curl -i -X DELETE "https://api.box.com/2.0/task_assignments/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Find item for shared link

Return the file or folder represented by a shared link.

Shared items are any files or folders that are represented by a shared link,
which can originate within the current enterprise or within another one.

This endpoint allows an application to retrieve information about a
shared item when only given a shared link.

```bash
curl -i -X GET "https://api.box.com/2.0/shared_items" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "boxapi: shared_link=https://app.box.com/s/gjasdasjhasd&shared_link_password=letmein"
```

The syntax is the same regardless of wether the shared link is a file or a folder.

```bash
curl -i -X GET "https://api.box.com/2.0/shared_items" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "boxapi: shared_link=https://app.box.com/s/jsasdsd8sad24&shared_link_password=letmein"
```

## Create web link

Creates a web link object within a folder.

```bash
curl -i -X POST "https://api.box.com/2.0/web_links" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "name": "Cloud Content Management",
       "url": "https://box.com",
       "parent": {
         "id": "0"
       }
     }'
```

## Get web link

Retrieve information about a web link.

```bash
curl -i -X GET "https://api.box.com/2.0/web_links/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Restore web link

Restores an web link that has been moved to the trash.

```bash
curl -i -X POST "https://api.box.com/2.0/web_links/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update web link

Updates a web link object.

```bash
curl -i -X PUT "https://api.box.com/2.0/web_links/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "name": "Cloud Content Management"
     }'
```

## Delete web link

Deletes a web link.

```bash
curl -i -X DELETE "https://api.box.com/2.0/web_links/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get trashed web link

Retrieves a web link that has been moved to the trash.

```bash
curl -i -X GET "https://api.box.com/2.0/web_links/12345/trash" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Permanently delete web link

Permanently deletes a web link that is in the trash.
This action cannot be undone.

```bash
curl -i -X DELETE "https://api.box.com/2.0/web_links/12345/trash" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List enterprise users

Returns a list of all users for the Enterprise along with their user_id,
public_name, and login.

The application and the authenticated user need to
have the permission to look up users in the entire
enterprise.

```bash
curl -i -X GET "https://api.box.com/2.0/users" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create user

Creates a new managed user in an enterprise. This endpoint
is only available to users and applications with the right
admin permissions.

```bash
curl -i -X POST "https://api.box.com/2.0/users" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "login": "ceo@example.com",
       "name": "Aaron Levie"
     }'
```

## Get authenticated user

Retrieves information about the user who is currently authenticated.

In the case of a 3-legged OAuth2, client-side authenticated application
this will be the user who authorized the app.

In the case of a JWT, server-side authenticated application
this will be the service account that belongs to the application
by default.

Use the `As-User` header to change who this API call is made on behalf of.

```bash
curl -i -X GET "https://api.box.com/2.0/users/me" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get user

Retrieves information about a user in the enterprise.

The application and the authenticated user need to
have the permission to look up users in the entire
enterprise.

This endpoint also returns a limited set of information
for external users who are collaborated on content
owned by the enterprise for authenticated users with the
right scopes. In this case, disallowed fields will return
null instead.

```bash
curl -i -X GET "https://api.box.com/2.0/users/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update user

Updates a managed user in an enterprise. This endpoint
is only available to users and applications with the right
admin permissions.

```bash
curl -i -X PUT "https://api.box.com/2.0/users/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "name": "Aaron Levie"
     }'
```

## Delete user

Deletes a user. By default this will fail if the user
still owns any content. Move their owned content first
before proceeding, or use the `force` field to delete
the user and their files.

```bash
curl -i -X DELETE "https://api.box.com/2.0/users/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get user avatar

Retrieves an image of a the user's avatar.

```bash
curl -i -X GET "https://api.box.com/2.0/users/12345/avatar" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Add or update user avatar

Uploads or updates a user avatar.

```bash
curl -i -L -X POST "https://api.box.net/2.0/users/12345/avatar" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     --form 'pic=@"path/to/file/file.jpeg"'
```

## Delete user avatar

Deletes a user avatar.

```bash
curl -i -X DELETE -L "https://api.box.net/2.0/users/12345/avatar" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Transfer owned folders

Move all of the items owned by a user into a
new folder in another user’s account.

Only the root folder (`0`) can be transferred.

Folders can only be moved across users by users with administrative
permissions.

This call will be performed synchronously which might lead to a slow response
when the source user has a large number of items in all of its folders.

If the destination path has a metadata cascade policy attached to any of
the parent folders, a metadata cascade operation will be kicked off
asynchronously.

There is currently no way to check for when this operation is finished.

```bash
curl -i -X PUT "https://api.box.com/2.0/users/12345/folders/0" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "owned_by": {
         "id": "1232234"
       }
     }'
```

## List user's email aliases

Retrieves all email aliases for a user. The collection
does not include the primary login for the user.

```bash
curl -i -X GET "https://api.box.com/2.0/users/12345/email_aliases" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create email alias

Adds a new email alias to a user account.

```bash
curl -i -X POST "https://api.box.com/2.0/users/12345/email_aliases" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "email": "alias@example.com"
     }'
```

## Remove email alias

Removes an email alias from a user.

```bash
curl -i -X DELETE "https://api.box.com/2.0/users/12345/email_aliases/23432" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List user's groups

Retrieves all the groups for a user. The user making
an API call must have admin permissions to inspect the
enterprise's groups.

```bash
curl -i -X GET "https://api.box.com/2.0/users/12345/memberships" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Invite user

Invites an existing external user to join an enterprise.

The existing user can not be part of another enterprise and
must already have a Box account. Once invited, the user will receive an
email and are prompted to accept the invitation within the
Box web application.

This method requires the "Manage An Enterprise" scope enabled for
the application, which can be enabled within the developer console.

```bash
curl -i -X POST "https://api.box.com/2.0/invites" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "enterprise": {
         "id": "1232234"
       },
       "actionable_by": {
         "login" : "freeuser@box.com"
       }
     }'
```

## Get user invite status

Returns the status of a user invite.

```bash
curl -i -X GET "https://api.box.com/2.0/invites/213723" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List enterprise groups

Retrieves all of the groups for a given enterprise. The user
must have admin permissions to inspect enterprise's groups.

```bash
curl -i -X GET "https://api.box.com/2.0/groups" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create group

Creates a new group of users in an enterprise. Only users with admin
permissions can create new groups.

```bash
curl -i -X POST "https://api.box.com/2.0/groups" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "name": "Customer Support"
     }'
```

## Get group

Retrieves information about a group.

```bash
curl -i -X GET "https://api.box.com/2.0/groups/57645" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update group

Updates a specific group.

```bash
curl -i -X PUT "https://api.box.com/2.0/groups/57645" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "name": "Customer Support"
     }'
```

## Delete group

Permanently deletes a group.

```bash
curl -i -X DELETE "https://api.box.com/2.0/groups/57645" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List group's members

Retrieves all the members for a group. The user
must have admin permissions to inspect enterprise's groups.

```bash
curl -i -X GET "https://api.box.com/2.0/groups/57645/memberships" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List group's collaborations

Retrieves all the collaborations for a group. The user
must have admin permissions to inspect enterprise's groups.

Each collaboration object has details on which files or
folders the group has access to and with what role.

```bash
curl -i -X GET "https://api.box.com/2.0/groups/57645/collaborations" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Add user to group

Creates a group membership

```bash
curl -i -X POST "https://api.box.com/2.0/group_memberships" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "user": {
         "id": "1434325"
       },
       "group": {
         "id": "4545523"
       }
     }'
```

## Get group membership

Retrieves a specific group membership.

```bash
curl -i -X GET "https://api.box.com/2.0/group_memberships/434534" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update user's membership

Updates a user's group membership.

```bash
curl -i -X PUT "https://api.box.com/2.0/group_memberships/434534" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "role": "admin"
     }'
```

## Remove user from group

Deletes a specific group membership.

```bash
curl -i -X DELETE "https://api.box.com/2.0/group_memberships/434534" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List all webhooks

Returns all defined webhooks for the requesting application.

```bash
curl -i -X GET "https://api.box.com/2.0/webhooks" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create webhook

Creates a webhook.

```bash
curl -i -X POST "https://api.box.com/2.0/webhooks" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "target": {
         "id": "21322",
         "type": "file"
       },
       "address": "https://example.com/webhooks",
       "triggers": [
         "FILE.PREVIEWED"
       ]
     }'
```

```bash
curl -i -X POST "https://api.box.com/2.0/webhooks" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "target": {
         "id": "234234",
         "type": "folder"
       },
       "address": "https://example.com/webhooks",
       "triggers": [
         "FILE.UPLOADED"
       ]
     }'
```

## Get webhook

Retrieves a specific webhook

```bash
curl -i -X GET "https://api.box.com/2.0/webhooks/3321123" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update webhook

Updates a webhook.

```bash
curl -i -X PUT "https://api.box.com/2.0/webhooks/3321123" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "triggers": [
         "FILE.DOWNLOADED"
       ]
     }'
```

## Delete webhook

Deletes a webhook.

```bash
curl -i -X DELETE "https://api.box.com/2.0/webhooks/3321123" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update skill invocation

Updates the status, usage and response metadata of a
skill invocation.

```bash
curl -i -X PUT "https://api.box.com/2.0/skill_invocations/33243242" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "status": "success",
       "metadata": {
         "cards": [{
            "type": "skill_card",
            "skill_card_type": "keyword",
            "skill_card_title": {
              "code": "license-plates",
              "message": "Licence Plates"
            },
            "skill": {
              "type": "service",
              "id": "license-plates-service"
            },
            "invocation": {
              "type": "skill_invocation",
              "id": "license-plates-service-123"
            },
            "entries": [
              { "text": "DD-26-YT" },
              { "text": "DN86 BOX" }
            ]
          },{
            "type": "skill_card",
            "skill_card_type": "transcript",
            "skill_card_title": {
              "code": "video-transcription",
              "message": "Video Transcription"
            },
            "skill": {
              "type": "service",
              "id": "video-transcription-service"
            },
            "invocation": {
              "type": "skill_invocation",
              "id": "video-transcription-service-123"
            },
            "duration": 1000,
            "entries": [
              {
                "text": "Hi John, have I told you about Box recently?",
                "appears": [{ "start": 0 }]
              },
              {
                "text": "No Aaron, you have not. Tell me more!",
                "appears": [{ "start": 5 }]
              }
            ]
          },{
            "type": "skill_card",
            "skill_card_type": "timeline",
            "skill_card_title": {
              "code": "face-detection",
              "message": "Faces"
            },
            "skill": {
              "type": "service",
              "id": "face-detection-service"
            },
            "invocation": {
              "type": "skill_invocation",
              "id": "face-detection-service-123"
            },
            "duration": 1000,
            "entries": [
              {
                "text": "John",
                "appears": [{ "start": 0, "end": 5 }, { "start": 10, "end": 15 }],
                "image_url": "https://example.com/john.png"
              },
              {
                "text": "Aaron",
                "appears": [{ "start": 5, "end": 10 }],
                "image_url": "https://example.com/aaron.png"
              }
            ]
          },{
            "type": "skill_card",
            "skill_card_type": "status",
            "skill_card_title": {
              "code": "hold",
              "message": "Please hold..."
            },
            "skill": {
              "type": "service",
              "id": "face-detection-service"
            },
            "invocation": {
              "type": "skill_invocation",
              "id": "face-detection-service-123"
            },
            "status": {
              "code": "processing",
              "message": "We are processing this file right now."
            }
          }]
       },
       "file": {
         "id": "12345"
       },
       "usage": {
         "unit": "file",
         "value": 1
       }
     }'
```

## List Skill cards on file

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345/metadata/global/boxSkillsCards" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create Skill cards on file

```bash
curl -i -X POST "https://api.box.com/2.0/files/12345/metadata/global/boxSkillsCards" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "cards": [{
         "type": "skill_card",
         "skill_card_type": "keyword",
         "skill_card_title": {
           "code": "license-plates",
           "message": "Licence Plates"
         },
         "skill": {
           "type": "service",
           "id": "license-plates-service"
         },
         "invocation": {
           "type": "skill_invocation",
           "id": "license-plates-service-123"
         },
         "entries": [
           { "text": "DD-26-YT" },
           { "text": "DN86 BOX" }
         ]
       },{
         "type": "skill_card",
         "skill_card_type": "transcript",
         "skill_card_title": {
           "code": "video-transcription",
           "message": "Video Transcription"
         },
         "skill": {
           "type": "service",
           "id": "video-transcription-service"
         },
         "invocation": {
           "type": "skill_invocation",
           "id": "video-transcription-service-123"
         },
         "duration": 1000,
         "entries": [
           {
             "text": "Hi John, have I told you about Box recently?",
             "appears": [{ "start": 0 }]
           },
           {
             "text": "No Aaron, you have not. Tell me more!",
             "appears": [{ "start": 5 }]
           }
         ]
       },{
         "type": "skill_card",
         "skill_card_type": "timeline",
         "skill_card_title": {
           "code": "face-detection",
           "message": "Faces"
         },
         "skill": {
           "type": "service",
           "id": "face-detection-service"
         },
         "invocation": {
           "type": "skill_invocation",
           "id": "face-detection-service-123"
         },
         "duration": 1000,
         "entries": [
           {
             "text": "John",
             "appears": [{ "start": 0, "end": 5 }, { "start": 10, "end": 15 }],
             "image_url": "https://example.com/john.png"
           },
           {
             "text": "Aaron",
             "appears": [{ "start": 5, "end": 10 }],
             "image_url": "https://example.com/aaron.png"
           }
         ]
       },{
         "type": "skill_card",
         "skill_card_type": "status",
         "skill_card_title": {
           "code": "hold",
           "message": "Please hold..."
         },
         "skill": {
           "type": "service",
           "id": "face-detection-service"
         },
         "invocation": {
           "type": "skill_invocation",
           "id": "face-detection-service-123"
         },
         "status": {
           "code": "processing",
           "message": "We are processing this file right now."
         }
       }]
     }'
```

## Update Skill cards on file

```bash
curl -i -X PUT "https://api.box.com/2.0/files/12345/metadata/global/boxSkillsCards" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json-patch+json" \
     -d '[{
       "op": "replace",
       "path": "/cards/0",
       "value": {
         "type": "skill_card",
         "skill_card_type": "keyword",
         "skill_card_title": {
           "code": "license-plates",
           "message": "Licence Plates"
         },
         "skill": {
           "type": "service",
           "id": "license-plates-service"
         },
         "invocation": {
           "type": "skill_invocation",
           "id": "license-plates-service-123"
         },
         "entries": [
           { "text": "DD-26-YT" },
           { "text": "DN86 BOX" }
         ]
       }
     }]'
```

## Delete Skill cards from file

```bash
curl -i -X DELETE "https://api.box.com/2.0/files/12345/metadata/global/boxSkillsCards" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get a long poll endpoint

Returns a list of real-time servers that can be used for long-polling updates
to the [event stream](#get-events).

Long polling is the concept where a HTTP request is kept open until the
server sends a response, then repeating the process over and over to receive
updated responses.

Long polling the event stream can only be used for user events, not for
enterprise events.

To use long polling, first use this endpoint to retrieve a list of long poll
URLs. Next, make a long poll request to any of the provided URLs.

When an event occurs in monitored account a response with the value
`new_change` will be sent. The response contains no other details as
it simply serves as a prompt to take further action such as sending a
request to the [events endpoint](#get-events) with the last known
`stream_position`.

After the server sends this response it closes the connection. You must now
repeat the long poll process to begin listening for events again.

If no events occur for a while and the connection times out you will
receive a response with the value `reconnect`. When you receive this response
you’ll make another call to this endpoint to restart the process.

If you receive no events in `retry_timeout` seconds then you will need to
make another request to the real-time server (one of the URLs in the response
for this endpoint). This might be necessary due to network errors.

Finally, if you receive a `max_retries` error when making a request to the
real-time server, you should start over by making a call to this endpoint
first.

```bash
curl -i -X OPTIONS "https://api.box.com/2.0/events" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get user and enterprise events

Returns up to a year of past events for a given user
or for the entire enterprise.

By default this returns events for the authenticated user. To retrieve
events for the entire enterprise, set the `stream_type` to `admin_logs`
(historical - 1 year) or `admin_logs_streaming` (live - two weeks). The user
making the API call will need to have admin privileges, and the application will
need to have the permission to access the event feed to get the enterprise event
feed.

```bash
curl -i -X GET "https://api.box.com/2.0/events" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

```bash
curl -i -X GET "https://api.box.com/2.0/events?stream_type=admin_logs" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

```bash
curl -i -X GET "https://api.box.com/2.0/events?stream_type=admin_logs&event_type=LOGIN,FAILED_LOGIN" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

```bash
curl -i -X GET "https://api.box.com/2.0/events?stream_type=admin_logs_streaming" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

```bash
curl -i -X GET "https://api.box.com/2.0/events?stream_type=admin_logs_streaming&event_type=LOGIN,FAILED_LOGIN" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List all collections

Retrieves all collections for a given user.

Currently, only the `favorites` collection
is supported.

```bash
curl -i -X GET "https://api.box.com/2.0/collections" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List collection items

Retrieves the files and/or folders contained within
this collection.

```bash
curl -i -X GET "https://api.box.com/2.0/collections/926489/items" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Add file to collection

```bash
curl -i -X PUT "https://api.box.com/2.0/files/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "collections": [
          {
            "id": "123"
          }
       ]
     }'
```

## Add folder to collection

```bash
curl -i -X PUT "https://api.box.com/2.0/folders/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "collections": [
          {
            "id": "123"
          }
       ]
     }'
```

## Add web link to collection

```bash
curl -i -X PUT "https://api.box.com/2.0/web_links/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "collections": [
          {
            "id": "123"
          }
       ]
     }'
```

## Remove file from collection

```bash
curl -i -X PUT "https://api.box.com/2.0/files/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "collections": []
     }'
```

## Remove folder from collection

## Remove web link from collection

## List recent items

Returns information about the recent items accessed
by a user, either in the last 90 days or up to the last
1000 items accessed.

```bash
curl -i -X GET "https://api.box.com/2.0/recent_items" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List retention policies

Retrieves all of the retention policies for an enterprise.

```bash
curl -i -X GET "https://api.box.com/2.0/retention_policies" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create retention policy

Creates a retention policy.

```bash
curl -i -X POST "https://api.box.com/2.0/retention_policies" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "policy_name": "Some Policy Name",
       "policy_type": "finite",
       "retention_length": 365,
       "disposition_action": "permanently_delete"
     }'
```

## Get retention policy

Retrieves a retention policy.

```bash
curl -i -X GET "https://api.box.com/2.0/retention_policies/982312" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update retention policy

Updates a retention policy.

```bash
curl -i -X PUT "https://api.box.com/2.0/retention_policies/982312" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "disposition_action": "permanently_delete"
     }'
```

## List policy's assignments

Returns a list of all retention policy assignments associated with a specified
retention policy.

```bash
curl -i -X GET "https://api.box.com/2.0/retention_policies/982312/assignments" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Assign retention policy

Assigns a retention policy to an item.

```bash
curl -i -X POST "https://api.box.com/2.0/retention_policy_assignments" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "policy_id": "173463",
       "assign_to": {
         "type": "folder",
         "id": "6564564"
       }
     }'
```

## Get policy assignment

Retrieves a retention policy assignment

```bash
curl -i -X GET "https://api.box.com/2.0/retention_policy_assignments/1233123" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List all legal hold policies

Retrieves a list of legal hold policies that belong to
an enterprise.

```bash
curl -i -X GET "https://api.box.com/2.0/legal_hold_policies" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create legal hold policy

Create a new legal hold policy.

```bash
curl -i -X POST "https://api.box.com/2.0/legal_hold_policies" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "policy_name": "Policy 3",
       "description": "Automatic created policy"
     }'
```

## Get legal hold policy

Retrieve a legal hold policy.

```bash
curl -i -X GET "https://api.box.com/2.0/legal_hold_policies/324432" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update legal hold policy

Update legal hold policy.

```bash
curl -i -X PUT "https://api.box.com/2.0/legal_hold_policies/324432" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "policy_name": "Policy 4"
     }'
```

## Delete legal hold policy

Delete an existing legal hold policy.

This is an asynchronous process. The policy will not be
fully deleted yet when the response returns.

```bash
curl -i -X DELETE "https://api.box.com/2.0/legal_hold_policies/324432" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List policy's assignments

Retrieves a list of items a legal hold policy has been assigned to.

```bash
curl -i -X GET "https://api.box.com/2.0/legal_hold_policy_assignments?policy_id=324432" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Assign legal hold policy

Assign a legal hold to a file, file version, folder, or user.

```bash
curl -i -X POST "https://api.box.com/2.0/legal_hold_policy_assignments" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "policy_id": "123244",
       "assign_to": {
         "type": "folder",
         "id": "6564564"
       }
     }'
```

## Get policy assignment

Retrieve a legal hold policy assignment.

```bash
curl -i -X GET "https://api.box.com/2.0/legal_hold_policy_assignments/753465" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Unassign legal hold policy

Remove a legal hold from an item.

This is an asynchronous process. The policy will not be
fully removed yet when the response returns.

```bash
curl -i -X DELETE "https://api.box.com/2.0/legal_hold_policy_assignments/753465" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get retention for file

Returns information about a file version retention.

```bash
curl -i -X GET "https://api.box.com/2.0/file_version_retentions/3424234" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List retentions on files

Retrieves all file version retentions for the given enterprise.

```bash
curl -i -X GET "https://api.box.com/2.0/file_version_retentions" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List files under retention for a retention policy

Retrieves all files for the given retention policy id.

```bash
curl -i -X GET "https://app.box.com/api/2.0/retention_policy_assignments/3424234/files_under_retention" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List file versions under retention for a retention policy

Retrieves all file versions for the given retention policy id.

```bash
curl -i -X GET "https://app.box.com/api/2.0/retention_policy_assignments/3424234/file_versions_under_retention" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Inspect legal hold on file

Retrieves information about the legal hold policies
assigned to a file version.

```bash
curl -i -X GET "https://api.box.com/2.0/file_version_legal_holds/2348213" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List legal holds for policy

Get list of non-deleted legal holds for a single legal
hold policy.

```bash
curl -i -X GET "https://api.box.com/2.0/file_version_legal_holds?policy_id=133870" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get device pin

Retrieves information about an individual device pin.

```bash
curl -i -X GET "https://api.box.com/2.0/device_pinners/2324234" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Delete device pin

Deletes an individual device pin.

```bash
curl -i -X DELETE "https://api.box.com/2.0/device_pinners/2324234" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List enterprise device pins

Retrieves all the device pins within an enterprise.

The user must have admin privileges, and the application
needs the "manage enterprise" scope to make this call.

```bash
curl -i -X GET "https://api.box.com/2.0/enterprises/3442311/device_pinners" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List terms of services

Returns the current terms of service text and settings
for the enterprise.

```bash
curl -i -X GET "https://api.box.com/2.0/terms_of_services" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create terms of service

Creates a terms of service for a given enterprise
and type of user.

```bash
curl -i -X POST "https://api.box.com/2.0/terms_of_services" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "status": "enabled",
       "text": "By collaborating on this file you are accepting..."
     }'
```

## Get terms of service

Fetches a specific terms of service.

```bash
curl -i -X GET "https://api.box.com/2.0/terms_of_services/324234" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update terms of service

Updates a specific terms of service.

```bash
curl -i -X PUT "https://api.box.com/2.0/terms_of_services/324234" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "status": "enabled",
       "text": "By collaborating on this file you are accepting..."
     }'
```

## List ToS user statuses

Retrieves an overview of users and their status for a
terms of service, including Whether they have accepted
the terms and when.

```bash
curl -i -X GET "https://api.box.com/2.0/terms_of_service_user_statuses?tos_id=324234" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Set status for new user

Sets the status for a terms of service for a user.

```bash
curl -i -X POST "https://api.box.com/2.0/terms_of_service_user_statuses" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "tos": {
         "type": "terms_of_service",
         "id": "1232132"
       },
       "user": {
         "type": "user",
         "id": "3423423"
       },
       "is_accepted": true
     }'
```

## Set status for existing user

Updates the status for a terms of service for a user.

```bash
curl -i -X PUT "https://api.box.com/2.0/terms_of_service_user_statuses/324234" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "is_accepted": true
     }'
```

## List whitelist entries

Returns the list of whitelist entries which specify what domains can
collaborate with the current enterprise.

```bash
curl -i -X GET "https://api.box.com/2.0/collaboration_whitelist_entries" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create whitelist entry

Creates a collaboration whitelist entry, specifying a domain
and direction to allow collaboration for.

```bash
curl -i -X POST "https://api.box.com/2.0/collaboration_whitelist_entries" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "domain": "example.com",
       "direction": "inbound"
     }'
```

## Get whitelist entry

Returns a specific collaboration whitelist entry.

```bash
curl -i -X GET "https://api.box.com/2.0/collaboration_whitelist_entries/213123" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Delete whitelist entry

Deletes a specific collaboration whitelist entry.

```bash
curl -i -X DELETE "https://api.box.com/2.0/collaboration_whitelist_entries/213123" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List whitelist exemptions

Returns a list of users who have been exempt from the collaboration
whitelist.

```bash
curl -i -X GET "https://api.box.com/2.0/collaboration_whitelist_exempt_targets" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create whitelist exemption

Creates a collaboration whitelist entry exemption, specifying a user
that is exempted from the whitelist.

```bash
curl -i -X POST "https://api.box.com/2.0/collaboration_whitelist_exempt_targets" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "user": {
         "id": "23522323"
       }
     }'
```

## Get whitelist exemption

Returns a users who has been exempt from the collaboration
whitelist.

```bash
curl -i -X GET "https://api.box.com/2.0/collaboration_whitelist_exempt_targets/984923" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Remove whitelist exemption

Deletes a specific collaboration whitelist exemption.

```bash
curl -i -X DELETE "https://api.box.com/2.0/collaboration_whitelist_exempt_targets/984923" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List storage policies

Fetches all the storage policies in the enterprise.

```bash
curl -i -X GET "https://api.box.com/2.0/storage_policies" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get storage policy

Fetches a specific storage policy.

```bash
curl -i -X GET "https://api.box.com/2.0/storage_policies/34342" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List policy assignments

Fetches all the storage policy assignment for an enterprise or user.

```bash
curl -i -X GET "https://api.box.com/2.0/storage_policy_assignments?resolved_for_type=user&resolved_for_id=984322" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Assign storage policy

Creates a storage policy assignment for an enterprise or user.

```bash
curl -i -X POST "https://api.box.com/2.0/storage_policy_assignments" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "storage_policy": {
         "type": "storage_policy",
         "id": "1434325"
       },
       "assigned_to": {
         "type": "user",
         "id": "9987987"
       }
     }'
```

## Get policy assignment

Fetches a specific storage policy assignment.

```bash
curl -i -X GET "https://api.box.com/2.0/storage_policy_assignments/932483" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update policy assignment

Updates a specific storage policy assignment.

```bash
curl -i -X PUT "https://api.box.com/2.0/storage_policy_assignments/932483" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "storage_policy": {
         "type": "storage_policy",
         "id": "1434325"
       }
     }'
```

## Unassign storage policy

Delete a storage policy assignment.

Deleting a storage policy assignment on a user
will have the user inherit the enterprise's default
storage policy.

There is a rate limit for calling this endpoint of only
twice per user in a 24 hour period.

```bash
curl -i -X DELETE "https://api.box.com/2.0/storage_policy_assignments/932483" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
       "items": {
         "type": "storage_policy",
         "id": "1434325"
       }
     }'
```

## Create zip download

```bash
curl -i -X POST "https://api.box.com/2.0/zip_downloads" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
       "download_file_name": "January Financials",
       "items": [
         {
           "type": "file",
           "id": "12345"
         },
         {
           "type": "file",
           "id": "34325"
         },
         {
           "type": "folder",
           "id": "45678"
         }
       ]
     }'
```

## Get zip download status

```bash
curl -i -X GET "https://api.box.com/2.0/zip_downloads/29l00nfxDyHOt7RphI9zT_w==nDnZEDjY2S8iEWWCHEEiptFxwoWojjlibZjJ6geuE5xnXENDTPxzgbks_yY=/status" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Download zip archive

```bash
curl -L -X GET "https://dl.boxcloud.com/2.0/zip_downloads/29l00nfxDyHOt7RphI9zT_w==nDnZEDjY2S8iEWWCHEEiptFxwoWojjlibZjJ6geuE5xnXENDTPxzgbks_yY=/content" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -o sample_curl.zip
```

## List all classifications

```bash
curl -i -X GET "https://api.box.com/2.0/metadata_templates/enterprise/securityClassification-6VMVochwUWo/schema" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Add initial classifications

```bash
curl -i -X POST "https://api.box.com/2.0/metadata_templates/schema" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "templateKey": "securityClassification-6VMVochwUWo",
       "scope": "enterprise",
       "displayName": "Classification",
       "hidden": false,
       "copyInstanceOnItemCopy": true,
       "fields": [
         {
           "type": "enum",
           "key": "Box__Security__Classification__Key",
           "displayName": "Classification",
           "hidden": false,
           "options": [
             {
               "key": "Classified",
               "staticConfig": {
                 "classification": {
                   "colorID": 7,
                   "classificationDefinition": "Top Seret"
                 }
               }
             }
           ]
         }
       ]
     }'
```

## Add another classification

```bash
curl -i -X PUT "https://api.box.com/2.0/metadata_templates/enterprise/securityClassification-6VMVochwUWo/schema" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json-patch+json" \
     -d '[{
       "op": "addEnumOption",
       "fieldKey": "Box__Security__Classification__Key",
       "data": {
         "key": "Sensitive",
         "staticConfig":{
          "classification": {
            "classificationDefinition": "Sensitive information that must not be shared.",
            "colorID": 4
            }
         }
       }
     }]'
```

## Update classification

```bash
curl -i -X PUT "https://api.box.com/2.0/metadata_templates/enterprise/securityClassification-6VMVochwUWo/schema" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json-patch+json" \
     -d '[{
       "op": "editEnumOption",
       "fieldKey": "Box__Security__Classification__Key",
       "enumOptionKey": "Sensitive",
       "data": {
         "key": "Very Sensitive",
         "staticConfig": {
           "classification": {
            "classificationDefinition": "Sensitive information that must not be shared.",
            "colorID": 4
           }
         }
       }
     }]'
```

## Delete classification

## Delete all classifications

```bash
curl -i -X DELETE "https://api.box.com/2.0/metadata_templates/enterprise/securityClassification-6VMVochwUWo/schema" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get classification on file

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345/metadata/enterprise/securityClassification-6VMVochwUWo" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Add classification to file

```bash
curl -i -X POST "https://api.box.com/2.0/files/12345/metadata/enterprise/securityClassification-6VMVochwUWo" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "Box__Security__Classification__Key": "Sensitive"

}'
```

## Update classification on file

```bash
curl -i -X PUT "https://api.box.com/2.0/files/12345/metadata/enterprise/securityClassification-6VMVochwUWo" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json-patch+json" \
     -d '[{
       "op": "replace",
       "path": "/Box__Security__Classification__Key",
       "value": "Internal"
     }]'
```

## Remove classification from file

```bash
curl -i -X DELETE "https://api.box.com/2.0/files/12345/metadata/enterprise/securityClassification-6VMVochwUWo" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get classification on folder

```bash
curl -i -X GET "https://api.box.com/2.0/folders/12345/metadata/enterprise/securityClassification-6VMVochwUWo" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Add classification to folder

```bash
curl -i -X POST "https://api.box.com/2.0/folders/12345/metadata/enterprise/securityClassification-6VMVochwUWo" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "Box__Security__Classification__Key": "Sensitive"
     }'
```

## Update classification on folder

```bash
curl -i -X PUT "https://api.box.com/2.0/folders/12345/metadata/enterprise/securityClassification-6VMVochwUWo" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json-patch+json" \
     -d '[{
       "op": "replace",
       "path": "/Box__Security__Classification__Key",
       "value": "Internal"
     }]'
```

## Remove classification from folder

```bash
curl -i -X DELETE "https://api.box.com/2.0/folders/12345/metadata/enterprise/securityClassification-6VMVochwUWo" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Copy a file request

```bash
curl -i -X POST "https://api.box.com/2.0/file_requests/42037322/copy" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
       "title": "Please upload required documents",
       "description": "Please upload required documents",
       "status": "active",
       "is_email_required": true,
       "is_description_required": false,
       "folder": {
         "id": "2233212",
         "type": "folder"
       }
     }'
```

## Update a file request

```bash
curl -i -X PUT "https://api.box.com/2.0/file_requests/42037322" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
       "title": "Please upload required documents",
       "description": "Please upload required documents",
       "status": "active",
       "is_email_required": true,
       "is_description_required": false
     }'
```

## Get a file request

```bash
curl -i -X GET "https://api.box.com/2.0/file_requests/42037322" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Delete a file request

```bash
curl -i -X DELETE "https://api.box.com/2.0/file_requests/42037322" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get shared link on a file

```bash
curl -i -X GET "https://api.box.com/2.0/files/32423234?fields=shared_link" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Add shared link to a file

```bash
curl -i -X PUT "https://api.box.com/2.0/files/32423234?fields=shared_link" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
       "shared_link": {
         "access": "open",
         "password": "mypassword",
         "unshared_at": "2012-12-12T10:53:43-08:00",
         "permissions": {
           "can_download": false
         }
       }
     }'
```

## Update shared link on a file

## Remove shared link from a file

```bash
curl -i -X PUT "https://api.box.com/2.0/files/32423234?fields=shared_link" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
       "shared_link": null
     }'
```

## Get shared link on a folder

```bash
curl -i -X GET "https://api.box.com/2.0/folders/32423234?fields=shared_link" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Add shared link to a folder

```bash
curl -i -X PUT "https://api.box.com/2.0/folders/32423234?fields=shared_link" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
       "shared_link": {
         "access": "open",
         "password": "mypassword",
         "unshared_at": "2012-12-12T10:53:43-08:00",
         "permissions": {
           "can_download": false
         }
       }
     }'
```

## Update shared link on a folder

## Remove shared link from a folder

```bash
curl -i -X PUT "https://api.box.com/2.0/folders/32423234?fields=shared_link" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
       "shared_link": null
     }'
```

## Get shared link on a web link

```bash
curl -i -X GET "https://api.box.com/2.0/web_links/32423234?fields=shared_link" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Add shared link to a web link

```bash
curl -i -X PUT "https://api.box.com/2.0/web_links/32423234?fields=shared_link" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
       "shared_link": {
         "access": "open",
         "password": "mypassword",
         "unshared_at": "2012-12-12T10:53:43-08:00",
         "permissions": {
           "can_download": false
         }
       }
     }'
```

## Update shared link on a web link

## Remove shared link from a web link

```bash
curl -i -X PUT "https://api.box.com/2.0/web_links/32423234?fields=shared_link" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
       "shared_link": null
     }'
```

## Gets a relay workflow with flows that are of type WORKFLOW_MANUAL_START

```bash
curl -i -X GET "https://api.box.com/2.0/workflows?folder_id=324234" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Start a flow in a relay workflow of type WORKFLOW_MANUAL_START

```bash
curl -i -X POST "https://api.box.com/2.0/workflows/42037322/start" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
       "type": "workflow_parameters",
       "flow": {
        "id": "8937625",
        "type": "flow"
       },
       "files": [{
          "type": "file",
          "id": "389047572"
        },
        {
          "type": "file",
          "id": "389047578"
        }],
       "folder": {
         "id": "2233212",
         "type": "folder"
       },
       "outcomes": [
          {
            "id": "34895783",
            "type": "outcome",
            "task_collaborators": {
                "type": "variable",
                "variable_type": "user_list",
                "variable_value": [{ "type": "user", "id": "890273642" }]
            },
            "completion_rule": {
                "type": "variable",
                "variable_type": "task_completion_rule",
                "variable_value": "all_assignees"
            },
            "file_collaborator_role": {
                "type": "variable",
                "variable_type": "collaborator_role",
                "variable_value": "viewer"
            }
          }
        ]
     }'
```

## Create Box Sign request

```bash
curl -i -X POST "https://api.box.com/2.0/sign_requests" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
       "signers": [
          {
            "role": "signer",
            "email": "example_email@box.com"
          }
        ],
       "source_files": [
          {
            "type": "file",
            "id": "123456789"
          }
       ],
       "parent_folder":
          {
            "type": "folder",
            "id": "0987654321"
          }
     }'
```

## Get Box Sign requests

```bash
curl -i -X GET "https://api.box.com/2.0/sign_requests" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get Box Sign request by ID

```bash
curl -i -X GET "https://api.box.com/2.0/sign_requests/<SIGN_REQUEST_ID>" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Cancel Box Sign request

```bash
curl -i -X POST "https://api.box.com/2.0/sign_requests/<SIGN_REQUEST_ID>/cancel" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Resend Box Sign request

```bash
curl -i -X POST "https://api.box.com/2.0/sign_requests/<SIGN_REQUEST_ID>/resend" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Terminate user sessions

```bash
curl -i -X POST "https://api.box.com/2.0/users/terminate_sessions" \
    -H "authorization: Bearer <ACCESS_TOKEN>" \
    -H "content-type: application/json" \
    -H "accept: application/json" \
    -d
  {
      user_ids: ["6178859178", "4824866571"]
      user_logins: ["user@example.com", "user2@example.com",]
  }
```

## Terminate groups sessions

```bash
curl -i -X POST "https://api.box.com/2.0/groups/terminate_sessions" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -H "accept: application/json" \
     -d
    {
    "group_ids": ["6178859178", "4824866571"],
    }
```

## List integration mappings Slack

```bash
curl -L -X GET "https://api.box.com/2.0/integration_mappings/slack?partner_item_id=C987654321&box_item_id=123456789" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create integration mapping Slack

```bash
curl -L -X POST "https://api.box.com/2.0/integration_mappings/slack" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H 'content-type: application/json' \
     -d '{
          "partner_item": {
              "id": "C987654321",
              "type": "channel",
              "slack_workspace_id": "T5555555"
          },
          "box_item": {
              "id": "123456789",
              "type": "folder"
          }
      }'
```

## Update integration mapping Slack

```bash
curl -L -X PUT "https://api.box.com/2.0/integration_mappings/slack/512521" \
     -H "authorization: Bearer <ACCESS_TOKEN>"  \
     -H 'content-type: application/json'  \
     -d '{
         "options": {
            "is_access_management_disabled": true
        }
    }'
```

## Delete integration mapping Slack

```bash
curl -L -X DELETE "https://api.box.com/2.0/integration_mappings/slack/512521" \
     -H "authorization: Bearer <ACCESS_TOKEN>"  \
     -d ''
```

## Get Box Sign template by ID

```bash
curl -L -X GET "https://api.box.com/2.0/sign_templates/12345678" \
     -H "accept: application/json" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get Box Sign templates

```bash
curl -L -X GET "https://api.box.com/2.0/sign_templates?marker=JV9IRGZmieiBasejOG9yDCRNgd2ymoZIbjsxbJMjIs3kioVii&limit=1000" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List integration mappings Teams

```bash
curl -L -X GET "https://api.box.com/2.0/integration_mappings/teams" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create integration mapping Teams

```bash
curl -L -X POST "https://api.box.com/2.0/integration_mappings/teams" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H 'content-type: application/json' \
     -d '{
          "partner_item": {
              "id": "19%3ABCD-Avgfggkggyftdtfgghjhkhkhh%40thread:tacv2",
              "type": "channel",
              "team_id": "hjgjgjg-bhhj-564a-b643-hghgj685u",
              "tenant_id": "E1234567"
          },
          "box_item": {
              "id": "42037322",
              "type": "folder"
          }
      }'
```

## Update integration mapping Teams

```bash
curl -L -X PUT "https://api.box.com/2.0/integration_mappings/teams/12345" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H 'content-type: application/json'
```

## Delete integration mapping Teams

```bash
curl -L -X DELETE "https://api.box.com/2.0/integration_mappings/teams/342423" \
     -H "authorization: Bearer <ACCESS_TOKEN>"  \
     -d ''
```

## Create archive

```bash
curl -i -X POST "https://api.box.com/2.0/archives" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "name": "Some Archive Name",
       "description": "Some Archive Description"
     }'
```

## List archives

```bash
curl -i -X GET "https://api.box.com/2.0/archives" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update archive

```bash
curl -i -X PUT "https://api.box.com/2.0/archives/12345" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "name": "Some Archive Name",
       "description": "Some Archive Description"
     }'
```

## Delete archive

```bash
curl -i -X DELETE "https://api.box.com/2.0/archives/12345" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

# Bulk delete external users

```bash
curl -L -X POST "https://api.box.com/2.0/external_users/external_users_submit_delete_job" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -d '{
      "external_users":
        "type": "array"
        "description": "List of external users to delete."
        "items":
          "$ref: #/components/schemas/UserReference"
      }'
```

## List shield information barriers

Retrieves a list of shield information barrier objects
for the enterprise of JWT.

```bash
curl -i -X GET "https://api.box.com/2.0/shield_information_barriers" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get shield information barrier by ID

Get shield information barrier based on provided ID.

```bash
curl -i -X GET "https://api.box.com/2.0/shield_information_barriers/1910967" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create shield information barrier

Creates a shield information barrier to separate
individuals/groups within the same firm and prevents
confidential information passing between them.

```bash
curl -i -X POST "https://api.box.com/2.0/shield_information_barriers" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "enterprise": {
         "id": "1910967",
         "type": "enterprise"
       }
     }'
```

## Change status of shield information barrier

Change status of shield information barrier with the
specified ID.

```bash
curl -i -X POST "https://api.box.com/2.0/shield_information_barriers/change_status" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "id": "1910967",
       "status": "pending"
     }'
```

## List shield information barrier reports

Lists shield information barrier reports.

```bash
curl -i -X GET "https://api.box.com/2.0/shield_information_barrier_reports?shield_information_barrier_id=1910967" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get shield information barrier report by ID

Retrieves a shield information barrier report by its ID.

```bash
curl -i -X GET "https://api.box.com/2.0/shield_information_barrier_reports/3423" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create shield information barrier report

Creates a shield information barrier report for a
given barrier.

```bash
curl -i -X POST "https://api.box.com/2.0/shield_information_barrier_reports" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "shield_information_barrier": {
         "id": "11446498",
         "type": "shield_information_barrier"
       }
     }'
```

## List shield information barrier segments

Retrieves a list of shield information barrier segment
objects for the specified Information Barrier ID.

```bash
curl -i -X GET "https://api.box.com/2.0/shield_information_barrier_segments?shield_information_barrier_id=1910967" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get shield information barrier segment by ID

Retrieves shield information barrier segment based
on provided ID.

```bash
curl -i -X GET "https://api.box.com/2.0/shield_information_barrier_segments/3423" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create shield information barrier segment

Creates a shield information barrier segment.

```bash
curl -i -X POST "https://api.box.com/2.0/shield_information_barrier_segments" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "shield_information_barrier": {
         "id": "11446498",
         "type": "shield_information_barrier"
       },
       "name": "Investment Banking"
     }'
```

## Update shield information barrier segment

Updates the shield information barrier segment based
on provided ID.

```bash
curl -i -X PUT "https://api.box.com/2.0/shield_information_barrier_segments/3423" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "name": "Investment Banking",
       "description": "Corporate division that engages in advisory-based financial transactions on behalf of individuals, corporations, and governments."
     }'
```

## Delete shield information barrier segment

Deletes the shield information barrier segment based
on provided ID.

```bash
curl -i -X DELETE "https://api.box.com/2.0/shield_information_barrier_segments/3423" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List shield information barrier segment members

Lists shield information barrier segment members based
on provided segment IDs.

```bash
curl -i -X GET "https://api.box.com/2.0/shield_information_barrier_segment_members?shield_information_barrier_segment_id=3423" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get shield information barrier segment member by ID

Retrieves a shield information barrier segment member
by its ID.

```bash
curl -i -X GET "https://api.box.com/2.0/shield_information_barrier_segment_members/7815" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create shield information barrier segment member

Creates a new shield information barrier segment member.

```bash
curl -i -X POST "https://api.box.com/2.0/shield_information_barrier_segment_members" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "shield_information_barrier_segment": {
         "id": "432554",
         "type": "shield_information_barrier_segment"
       },
       "user": {
         "id": "11446498",
         "type": "user"
       }
     }'
```

## Delete shield information barrier segment member by ID

Deletes a shield information barrier segment member
based on provided ID.

```bash
curl -i -X DELETE "https://api.box.com/2.0/shield_information_barrier_segment_members/7815" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List shield information barrier segment restrictions

Lists shield information barrier segment restrictions
based on provided segment ID.

```bash
curl -i -X GET "https://api.box.com/2.0/shield_information_barrier_segment_restrictions?shield_information_barrier_segment_id=3423" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get shield information barrier segment restriction by ID

Retrieves a shield information barrier segment
restriction based on provided ID.

```bash
curl -i -X GET "https://api.box.com/2.0/shield_information_barrier_segment_restrictions/4563" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create shield information barrier segment restriction

Creates a shield information barrier segment
restriction object.

```bash
curl -i -X POST "https://api.box.com/2.0/shield_information_barrier_segment_restrictions" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "type": "shield_information_barrier_segment_restriction",
       "shield_information_barrier_segment": {
         "id": "1910967",
         "type": "shield_information_barrier_segment"
       },
       "restricted_segment": {
         "id": "1910967",
         "type": "shield_information_barrier_segment"
       }
     }'
```

## Delete shield information barrier segment restriction by ID

Delete shield information barrier segment restriction
based on provided ID.

```bash
curl -i -X DELETE "https://api.box.com/2.0/shield_information_barrier_segment_restrictions/4563" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List file app item associations

Returns all app items the file is associated with.

```bash
curl -i -X GET "https://api.box.com/2.0/files/12345/app_item_associations" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List folder app item associations

Returns all app items the folder is associated with.

```bash
curl -i -X GET "https://api.box.com/2.0/folders/12345/app_item_associations" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get collection by ID

Retrieves a collection by its ID.

```bash
curl -i -X GET "https://api.box.com/2.0/collections/926489" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Find metadata template by instance ID

Finds a metadata template by searching for the ID of
an instance of the template.

```bash
curl -i -X GET "https://api.box.com/2.0/metadata_templates?metadata_instance_id=01234500-12f1-1234-aa12-b1d234cb567e" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List files with current file versions for legal hold policy assignment

```bash
curl -i -X GET "https://api.box.com/2.0/legal_hold_policy_assignments/753465/files_on_hold" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List previous file versions for legal hold policy assignment

```bash
curl -i -X GET "https://api.box.com/2.0/legal_hold_policy_assignments/753465/file_versions_on_hold" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Delete retention policy

Permanently deletes a retention policy.

```bash
curl -i -X DELETE "https://api.box.com/2.0/retention_policies/982312" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Remove retention policy assignment

Removes a retention policy assignment applied to content.

```bash
curl -i -X DELETE "https://api.box.com/2.0/retention_policy_assignments/1233123" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Transfer owned folders

Move all of the items (files, folders and workflows)
owned by a user into another user's account.
Only the root folder (0) can be transferred.

## Update metadata taxonomy

Updates an existing metadata taxonomy.

```bash
curl -i -X PATCH "https://api.box.com/2.0/metadata_taxonomies/enterprise_123456/geography" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "displayName": "Geography"
     }'
```

## Update metadata taxonomy level

Updates an existing metadata taxonomy level.

```bash
curl -i -X PATCH "https://api.box.com/2.0/metadata_taxonomies/enterprise_123456/geography/levels/1" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "displayName": "France",
       "description": "French Republic"
     }'
```

## Update metadata taxonomy node

Updates an existing metadata taxonomy node.

```bash
curl -i -X PATCH "https://api.box.com/2.0/metadata_taxonomies/enterprise_123456/geography/nodes/14d3d433-c77f-49c5-b146-9dea370f6e32" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "displayName": "France"
     }'
```

## Add metadata taxonomy level

Creates a new metadata taxonomy level and appends it
to the existing levels.

```bash
curl -i -X POST "https://api.box.com/2.0/metadata_taxonomies/enterprise_123456/geography/levels:append" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "displayName": "City",
       "description": "City Level"
     }'
```

## List all Box Hubs

Retrieves all Box Hubs for requesting user.

```bash
curl -i -X GET "https://api.box.com/2.0/hubs" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create Box Hub

Creates a new Box Hub.

```bash
curl -i -X POST "https://api.box.com/2.0/hubs" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "title": "Hub Title",
       "description": "This is a description of the Box Hub."
     }'
```

## List all Box Hubs for enterprise

Retrieves all Box Hubs for a given enterprise.

```bash
curl -i -X GET "https://api.box.com/2.0/enterprise_hubs" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get Box Hub by ID

Retrieves details for a Box Hub by its ID.

```bash
curl -i -X GET "https://api.box.com/2.0/hubs/12345" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update Box Hub by ID

Updates a Box Hub. Can be used to change title,
description, or Box Hub settings.

```bash
curl -i -X PUT "https://api.box.com/2.0/hubs/12345" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "title": "Updated Hub Title",
       "description": "Updated description of the Box Hub."
     }'
```

## Delete Box Hub

Deletes a single Box Hub.

```bash
curl -i -X DELETE "https://api.box.com/2.0/hubs/12345" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Copy Box Hub

Creates a copy of a Box Hub.

```bash
curl -i -X POST "https://api.box.com/2.0/hubs/12345/copy" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "title": "Copied Hub Title",
       "description": "A copy of the original Box Hub."
     }'
```

## Get Box Hub collaborations

Retrieves all collaborations for a Box Hub.

```bash
curl -i -X GET "https://api.box.com/2.0/hub_collaborations?hub_id=12345" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create Box Hub collaboration

Adds a collaboration for a single user or a single
group to a Box Hub.

```bash
curl -i -X POST "https://api.box.com/2.0/hub_collaborations" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "hub": {
         "type": "hubs",
         "id": "42037322"
       },
       "accessible_by": {
         "type": "user",
         "id": "23522323"
       },
       "role": "viewer"
     }'
```

## Get Box Hub collaboration by ID

Retrieves details for a Box Hub collaboration by
collaboration ID.

```bash
curl -i -X GET "https://api.box.com/2.0/hub_collaborations/1234" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update Box Hub collaboration

Updates a Box Hub collaboration. Can be used to change
the Box Hub role.

```bash
curl -i -X PUT "https://api.box.com/2.0/hub_collaborations/1234" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "role": "editor"
     }'
```

## Remove Box Hub collaboration

Deletes a single Box Hub collaboration.

```bash
curl -i -X DELETE "https://api.box.com/2.0/hub_collaborations/1234" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get Box Hub items

Retrieves all items associated with a Box Hub.

```bash
curl -i -X GET "https://api.box.com/2.0/hub_items?hub_id=12345" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Manage Box Hub items

Adds and/or removes Box Hub items from a Box Hub.

```bash
curl -i -X POST "https://api.box.com/2.0/hubs/12345/manage_items" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "operations": [
         {
           "action": "add",
           "item": {
             "type": "folder",
             "id": "123456789"
           }
         }
       ]
     }'
```

## List Hub Document pages

Retrieves a list of Hub Document Pages for
the specified hub.

```bash
curl -i -X GET "https://api.box.com/2.0/hub_document_pages?hub_id=12345" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## List Hub Document blocks for page

Retrieves a sorted list of all Hub Document Blocks
on a specified page in the hub document.

```bash
curl -i -X GET "https://api.box.com/2.0/hub_document_blocks?hub_id=12345&page_id=d97f7c26-0d9b-42a1-a00d-6e6db9619e0f" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get all shield lists

Retrieves all shield lists in the enterprise.

```bash
curl -i -X GET "https://api.box.com/2.0/shield_lists" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Create shield list

Creates a shield list.

```bash
curl -i -X POST "https://api.box.com/2.0/shield_lists" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "name": "My Shield List",
       "description": "A list of things that are shielded",
       "content": {
         "type": "country",
         "country_codes": ["US", "PL"]
       }
     }'
```

## Get shield list by ID

Retrieves a single shield list by its ID.

```bash
curl -i -X GET "https://api.box.com/2.0/shield_lists/90fb0e17-c332-40ed-b4f9-fa8908fbbb24" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Update shield list

Updates a shield list.

```bash
curl -i -X PUT "https://api.box.com/2.0/shield_lists/90fb0e17-c332-40ed-b4f9-fa8908fbbb24" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "name": "My Shield List",
       "description": "Updated description",
       "content": {
         "type": "country",
         "country_codes": ["US"]
       }
     }'
```

## Delete shield list

Delete a single shield list by its ID.

```bash
curl -i -X DELETE "https://api.box.com/2.0/shield_lists/90fb0e17-c332-40ed-b4f9-fa8908fbbb24" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Get enterprise configuration

Retrieves the configuration for an enterprise.

```bash
curl -i -X GET "https://api.box.com/2.0/enterprise_configurations/3442311?categories=security,content_and_sharing" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Submit job to delete external users

Delete external users from current user enterprise.

```bash
curl -i -X POST "https://api.box.com/2.0/external_users/submit_delete_job" \
     -H "box-version: 2025.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "external_users": [
         {
           "type": "user",
           "id": "12345"
         }
       ]
     }'
```

## List Automate workflows

Returns workflow actions from Automate for a folder.

```bash
curl -i -X GET "https://api.box.com/2.0/automate_workflows?folder_id=12345" \
     -H "box-version: 2026.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>"
```

## Start Automate workflow

Starts an Automate workflow manually by using a
workflow action ID and file IDs.

```bash
curl -i -X POST "https://api.box.com/2.0/automate_workflows/12345/start" \
     -H "box-version: 2026.0" \
     -H "authorization: Bearer <ACCESS_TOKEN>" \
     -H "content-type: application/json" \
     -d '{
       "workflow_action_id": "981",
       "file_ids": ["123"]
     }'
```

box-curl-samples

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README