> ## Documentation Index
> Fetch the complete documentation index at: https://docs.squarecloud.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Enviar uma parte do upload em partes

> Envie uma parte de um upload em partes com PUT /v1/objects/chunked: bytes brutos, de 5 a 32 MB cada exceto a última, em qualquer ordem e com reenvio seguro.

<ParamField header="Authorization" type="string" placeholder="Chave da API" required>
  A chave da API para sua conta. Você pode encontrá-la nas [configurações da conta](https://squarecloud.app/pt-br/account/security).
</ParamField>

O Enviar Parte envia uma parte de um upload aberto com o [Início de Upload em Partes](/pt-br/blob-reference/endpoint/chunked-init). O corpo são os **bytes brutos** da parte, não multipart/form-data. Os números das partes vão de 1 a 2048 e podem ser enviados em **qualquer ordem**. Reenviar uma parte com o mesmo número a substitui, então uma parte que falhou pode simplesmente ser enviada de novo.

Toda parte, exceto a última, precisa ter de **5 MB a 32 MB**; a última pode ser menor. Envie no máximo **6 partes em paralelo** por conta: uma sétima responde `TOO_MANY_CONCURRENT_CHUNKS`, e você reenvia essa parte quando outra terminar. Com 6 em andamento, partes de 16 MB são um bom padrão para um navegador.

Esta rota tem o seu próprio limite de 60 partes a cada 10 segundos e não consome o orçamento de API da conta inteira, então um upload longo não esgota a sua cota de API para o resto da plataforma. Exige o escopo `blob:write`, ou o token de upload que abriu o upload, e um plano ativo.

## Parâmetros

<ParamField query="upload" type="string" required>
  O token `upload` retornado pelo Início de Upload em Partes.
</ParamField>

<ParamField query="part" type="number" placeholder="1" required>
  O número da parte, de 1 a 2048.
</ParamField>

<ParamField body="body" type="binary" required>
  Os bytes brutos da parte (`Content-Type: application/octet-stream`).
</ParamField>

## Resposta

<ResponseField name="status" type="string">
  "success" se bem-sucedida, "error" caso contrário.
</ResponseField>

<ResponseField name="response" type="object">
  <Expandable title="Alternar objeto">
    <ResponseField name="part" type="number">
      O número da parte armazenada.
    </ResponseField>

    <ResponseField name="size" type="number">
      O tamanho da parte, em bytes.
    </ResponseField>

    <ResponseField name="etag" type="string">
      O ETag da parte. Apenas informativo: o Concluir Upload lê a lista de partes no servidor, então você nunca o envia de volta.
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```bash cURL theme={"system"}
  curl --request PUT \
    --url 'https://blob.squarecloud.app/v1/objects/chunked?upload=UPLOAD_TOKEN&part=1' \
    --header 'Authorization: YOUR_API_KEY' \
    --header 'Content-Type: application/octet-stream' \
    --data-binary '@./chunk-1.bin'
  ```

  ```javascript JavaScript theme={"system"}
  const PART_SIZE = 16 * 1024 * 1024;
  const total = Math.ceil(file.size / PART_SIZE);

  async function sendPart(n) {
    const body = file.slice((n - 1) * PART_SIZE, n * PART_SIZE);
    const params = new URLSearchParams({ upload: uploadToken, part: String(n) });
    const res = await fetch(`https://blob.squarecloud.app/v1/objects/chunked?${params}`, {
      method: 'PUT',
      headers: { Authorization: 'YOUR_API_KEY', 'Content-Type': 'application/octet-stream' },
      body,
    });
    if (res.status === 429 || res.status >= 500) return sendPart(n); // add a backoff in production
    if (!res.ok) throw new Error((await res.json()).code);
  }

  // 6 workers, each taking the next part number
  let next = 1;
  await Promise.all(Array.from({ length: 6 }, async () => {
    while (next <= total) await sendPart(next++);
  }));
  ```

  ```python Python theme={"system"}
  import requests

  with open('./bigfile.bin', 'rb') as f:
      chunk = f.read(16 * 1024 * 1024)

  response = requests.put(
      'https://blob.squarecloud.app/v1/objects/chunked',
      headers={'Authorization': 'YOUR_API_KEY', 'Content-Type': 'application/octet-stream'},
      params={'upload': upload_token, 'part': 1},
      data=chunk,
  )
  ```
</RequestExample>

<ResponseExample>
  ```json theme={"system"}
  {
    "status": "success",
    "response": {
      "part": 1,
      "size": 16777216,
      "etag": "\"9bb58f26192e4ba00f01e2e7b136bbd8\""
    }
  }
  ```
</ResponseExample>

## Erros

| Código | HTTP | Quando |
| - | - | - |
| `INVALID_UPLOAD_TOKEN` | 400 | O token `upload` está ausente, malformado ou não é seu. |
| `INVALID_CHUNK_PART` | 400 | `part` não é um inteiro de 1 a 2048. |
| `EMPTY_CHUNK` | 400 | O corpo está vazio. |
| `PERMISSION_DENIED` | 401 | A conta não tem um plano ativo. |
| `UPLOAD_NOT_FOUND` | 404 | O upload foi concluído, cancelado ou expirou. |
| `CHUNK_TOO_LARGE` | 413 | A parte tem mais de 32 MB. |
| `FILE_TOO_LARGE` | 413 | Com esta parte, o upload passa do seu limite de tamanho. |
| `TOO_MANY_CONCURRENT_CHUNKS` | 429 | Já há 6 partes em andamento. Reenvie esta parte quando uma terminar. |
| `RATE_LIMITED` | 429 | Mais de 60 partes em 10 segundos. |
| `UPLOAD_FAILED` | 500 | A parte falhou. Envie-a novamente. |

## Relacionados

* SDK do Blob: [`blob.put()`](/pt-br/sdks/blob/uploads) executa todo o fluxo em partes para arquivos acima de 90 MiB


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.