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

> Cette documentation fournit une vue d'ensemble complète de l'endpoint PUT /v1/objects/chunked de l'API Blob de SquareCloud.

<ParamField header="Authorization" type="string" placeholder="API Key" required>
  La clé d'API de votre compte. Vous pouvez la trouver dans les [paramètres de votre compte](https://squarecloud.app/fr/account/security).
</ParamField>

Chunked Part envoie un chunk d'un upload ouvert avec [Chunked Init](/fr/blob-reference/endpoint/chunked-init). Le corps est constitué des **octets bruts** du chunk, pas de multipart/form-data. Les numéros de part vont de 1 à `max_parts` (205) et peuvent être envoyés dans **n'importe quel ordre** ; une part en échec peut simplement être renvoyée avec le même numéro, et ce renvoi est sans risque car les parts sont idempotentes.

Chaque chunk sauf le dernier doit être compris entre **5 Mo et 32 Mo** ; le dernier peut être plus petit. Envoyez au plus **6 parts en parallèle** : une septième part en vol renvoie `TOO_MANY_CONCURRENT_CHUNKS`, auquel cas attendez qu'une part se termine et réessayez celle-ci. Avec 6 parts en vol, des chunks de 16 Mo sont une bonne valeur par défaut pour un navigateur.

Cette route est exemptée du budget d'API global du compte (`plan.rate`), donc un upload long ne peut pas épuiser votre quota d'API pour le reste de la plateforme. Son propre limiteur autorise 60 parts par 10 secondes, avec un blocage de 10 secondes au-delà.

<ParamField query="upload" type="string" placeholder="Upload token" required>
  Le jeton `upload` opaque renvoyé par Chunked Init.
</ParamField>

<ParamField query="part" type="number" placeholder="1..205" required>
  Le numéro de part, de 1 à 205. Les parts peuvent être envoyées dans n'importe quel ordre.
</ParamField>

<ParamField body="body" type="binary" required>
  Les octets bruts du chunk (`Content-Type: application/octet-stream`). **Pas** de multipart/form-data.
</ParamField>

### Réponse

<ResponseField name="status" type="string">
  Indique si l'appel a réussi. "success" en cas de succès, "error" sinon.
</ResponseField>

<ResponseField name="response" type="object">
  <Expandable title="Afficher l'objet">
    <ResponseField name="part" type="number">
      Le numéro de la part qui a été stockée.
    </ResponseField>

    <ResponseField name="size" type="number">
      La taille du chunk stocké, en octets.
    </ResponseField>

    <ResponseField name="etag" type="string">
      L'ETag de stockage de la part. Purement informatif : la finalisation relit la liste des parts depuis le stockage, vous ne le renvoyez donc jamais.
    </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>

### Dépannage

<Tabs>
  <Tab title="Code de statut 400">
    ### Lié au chunk

    <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="Code de statut 401">
    ### Non autorisé

    <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="Code de statut 404">
    ### Introuvable

    <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="Code de statut 413">
    ### Charge utile trop volumineuse

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

  <Tab title="Code de statut 429">
    ### Limite de débit atteinte

    <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="Code de statut 500">
    ### Échec de l'upload

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