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

# Blob Chunked Upload Part

> Esta documentación ofrece una descripción completa del endpoint PUT /v1/objects/chunked de la API de SquareCloud Blob.

<ParamField header="Authorization" type="string" placeholder="API Key" required>
  La clave de API de tu cuenta. Puedes encontrarla en la [configuración de tu cuenta](https://squarecloud.app/es/account/security).
</ParamField>

Chunked Part envía un fragmento de una subida abierta con [Chunked Init](/es/blob-reference/endpoint/chunked-init). El cuerpo son los **bytes crudos** del fragmento, no multipart/form-data. Los números de parte van de 1 a `max_parts` (205) y pueden enviarse en **cualquier orden**; una parte fallida puede simplemente reenviarse con el mismo número, y reenviarla es seguro porque las partes son idempotentes.

Cada fragmento excepto el último debe estar entre **5 MB y 32 MB**; el último puede ser más pequeño. Envía como máximo **6 partes en paralelo**: una séptima parte en vuelo devuelve `TOO_MANY_CONCURRENT_CHUNKS`, en cuyo caso espera a que una termine y reintenta esa parte. Con 6 partes en vuelo, fragmentos de 16 MB son un buen valor por defecto para un navegador.

Esta ruta está exenta del presupuesto de API de la cuenta (`plan.rate`), así que una subida larga no puede agotar tu cuota de API para el resto de la plataforma. Su propio limitador permite 60 partes cada 10 segundos, con bloqueo de 10 segundos al superarlo.

<ParamField query="upload" type="string" placeholder="Upload token" required>
  El token `upload` opaco devuelto por Chunked Init.
</ParamField>

<ParamField query="part" type="number" placeholder="1..205" required>
  El número de parte, de 1 a 205. Las partes pueden enviarse en cualquier orden.
</ParamField>

<ParamField body="body" type="binary" required>
  Los bytes crudos del fragmento (`Content-Type: application/octet-stream`). **No** multipart/form-data.
</ParamField>

### Respuesta

<ResponseField name="status" type="string">
  Indica si la llamada fue exitosa. "success" si tuvo éxito, "error" si no.
</ResponseField>

<ResponseField name="response" type="object">
  <Expandable title="Alternar objeto">
    <ResponseField name="part" type="number">
      El número de la parte que se almacenó.
    </ResponseField>

    <ResponseField name="size" type="number">
      El tamaño del fragmento almacenado, en bytes.
    </ResponseField>

    <ResponseField name="etag" type="string">
      El ETag de almacenamiento de la parte. Solo informativo: la finalización vuelve a leer la lista de partes desde el almacenamiento, así que nunca lo envías de vuelta.
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  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={null}
  const chunk = file.slice(0, 16 * 1024 * 1024); // first 16 MB

  const params = new URLSearchParams({ upload: uploadToken, part: '1' });

  const response = await fetch(`https://blob.squarecloud.app/v1/objects/chunked?${params}`, {
    method: 'PUT',
    headers: {
      Authorization: 'YOUR_API_KEY',
      'Content-Type': 'application/octet-stream',
    },
    body: chunk,
  });
  ```

  ```python Python theme={null}
  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={null}
  {
    "status": "success",
    "response": {
      "part": 1,
      "size": 16777216,
      "etag": "\"9bb58f26192e4ba00f01e2e7b136bbd8\""
    }
  }
  ```
</ResponseExample>

### Solución de problemas

<Tabs>
  <Tab title="Código de estado 400">
    ### Relacionado con el fragmento

    <CodeGroup>
      ```json INVALID_UPLOAD_TOKEN theme={null}
      // The upload token is missing, malformed, or does not belong to your account.
      {
          "status": "error",
          "code": "INVALID_UPLOAD_TOKEN"
      }
      ```

      ```json INVALID_CHUNK_PART theme={null}
      // The part number must be an integer between 1 and 205.
      {
          "status": "error",
          "code": "INVALID_CHUNK_PART"
      }
      ```

      ```json EMPTY_CHUNK theme={null}
      // The chunk body was empty.
      {
          "status": "error",
          "code": "EMPTY_CHUNK"
      }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Código de estado 401">
    ### No autorizado

    <CodeGroup>
      ```json ACCESS_DENIED theme={null}
      // The API key is missing or invalid. Set a valid key in the Authorization header.
      {
          "status": "error",
          "code": "ACCESS_DENIED"
      }
      ```

      ```json PERMISSION_DENIED theme={null}
      // The account has no active paid plan. Uploading to Blob Storage requires a paid plan.
      {
          "status": "error",
          "code": "PERMISSION_DENIED"
      }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Código de estado 404">
    ### No encontrado

    <CodeGroup>
      ```json UPLOAD_NOT_FOUND theme={null}
      // The upload was already completed, aborted, or expired.
      {
          "status": "error",
          "code": "UPLOAD_NOT_FOUND"
      }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Código de estado 413">
    ### Carga útil demasiado grande

    <CodeGroup>
      ```json CHUNK_TOO_LARGE theme={null}
      // Each chunk accepts up to 32 MB.
      {
          "status": "error",
          "code": "CHUNK_TOO_LARGE"
      }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Código de estado 429">
    ### Límite de tasa alcanzado

    <CodeGroup>
      ```json RATE_LIMITED theme={null}
      // Part rate limit reached (60 parts per 10s window, blocked for 10s).
      {
          "status": "error",
          "code": "RATE_LIMITED"
      }
      ```

      ```json TOO_MANY_CONCURRENT_CHUNKS theme={null}
      // At most 6 chunks may be in flight at a time. Wait for one to finish, then retry this part.
      {
          "status": "error",
          "code": "TOO_MANY_CONCURRENT_CHUNKS"
      }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Código de estado 500">
    ### Fallo en la subida

    <CodeGroup>
      ```json UPLOAD_FAILED theme={null}
      // Failed to upload the chunk. Retry this part.
      {
          "status": "error",
          "code": "UPLOAD_FAILED"
      }
      ```
    </CodeGroup>
  </Tab>
</Tabs>