> This page is for Camera to Cloud.

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://next.developer.frame.io/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://next.developer.frame.io/_mcp/server.

# Demander des URL de chargement pour le chargement en temps réel

POST https://api.frame.io/v2/devices/assets/{asset_id}/realtime_upload/parts
Content-Type: application/json

Enregistrer les parties de chargement en temps réel et générer des URL PUT présignées pour le chargement vers AWS S3.

Reference: https://next.developer.frame.io/camera-to-cloud/api-reference/device-create-realtime-upload-parts

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Path parameters

- `asset_id` (string, required) — Asset ID

### Headers

- `x-client-version` (string, optional, default: 0.0.0) — Firmware or software version of a C2C integration. Will be used to determine the correct Device Model configuration for the device when multiple are available. Must be a valid semantic version. For more on semantic versions, see here: https://semver.org/

### Body (application/json)

This endpoint expects an object.

- `parts` (list of V2DevicesAssetsAssetIdRealtimeUploadPartsPostRequestBodyContentApplicationJsonSchemaPartsItems, required) — List of file upload parts to register with Frame.
- `asset_name` (string, optional) — Updates the asset name if only `extension` was supplied to assetCreate, and the default name is still in use. Otherwise, will be ignored.
- `asset_filesize` (integer, optional) — The full filesize for the upload in bytes. This field is required when an object in `parts` has `is_final` set to `true`. Must be no more than 5 TiB.

## Response

### 200

Returns array of upload URLs for created parts.

- `upload_urls` (list of string, required) — Array of AWS S3 presigned upload PUT URLs. Returned in the same order as the `parts` field of the request.

## Errors

### 400 Bad Request Error

Bad Request

- `code` (integer, optional)
- `errors` (list of HttpErrorErrorsItems, optional)
- `message` (string, optional)

### 401 Unauthorized Error

Unauthorized response

- `code` (integer, optional)
- `errors` (list of HttpErrorErrorsItems, optional)
- `message` (string, optional)

### 404 Not Found Error

Not Found response

- `code` (integer, optional)
- `errors` (list of HttpErrorErrorsItems, optional)
- `message` (string, optional)

### 429 Too Many Requests Error

Standard frame.io API error response.

- `code` (integer, optional)
- `errors` (list of HttpErrorErrorsItems, optional)
- `message` (string, optional)

## Types

### V2DevicesAssetsAssetIdRealtimeUploadPartsPostRequestBodyContentApplicationJsonSchemaPartsItems

- `number` (integer, required) — The part number/index, starting at 1. Part numbers may be skipped, and may be uploaded in any order, but will be used to concatinate the final file in sequentual order. Cannot be greater than 10,000 (the maximum number of parts that AWS allows).
- `size` (integer, required) — The size of the part in bytes. If the size does not abide by the [AWS Multi-Part upload restrictions](https://docs.aws.amazon.com/AmazonS3/latest/userguide/qfacts.html), an error will be returned. For instance, must be greater than or equal to 5 MiB, (5,242,880 bytes) is `is_final` is not t`true`.
- `is_final` (boolean, required) — Whether this is the final part of the file.

### HttpErrorErrorsItems

- `code` (integer, optional)
- `detail` (string, optional)
- `status` (integer, optional)
- `title` (string, optional)

## Examples

### Request non-final part

**Request**

```json
{
  "body": {
    "parts": [
      {
        "is_final": false,
        "number": 1,
        "size": 10568125
      }
    ]
  }
}
```

**SDK Code**

```typescript Request non-final part
const response = await fetch('https://api.frame.io/v2/devices/assets/{asset_id}/realtime_upload/parts', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer [access_token]',
    'Content-Type': 'application/json',
    'x-client-version': '2.0.0'
  },
  body: JSON.stringify({
    parts: [
      {
        number: 1,
        size: 10568125,
        is_final: false
      }
    ]
  })
});

const result = await response.json();
console.log(result);
```

```python Request non-final part
import requests

headers = {
    'Authorization': 'Bearer [access_token]',
    'Content-Type': 'application/json',
    'x-client-version': '2.0.0'
}

data = {
    'parts': [
        {
            'number': 1,
            'size': 10568125,
            'is_final': False
        }
    ]
}

response = requests.post(
    'https://api.frame.io/v2/devices/assets/{asset_id}/realtime_upload/parts',
    headers=headers,
    json=data
)

result = response.json()
print(result)
```

```go Request non-final part
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.frame.io/v2/devices/assets/:asset_id/realtime_upload/parts"

	payload := strings.NewReader("{\n  \"body\": {\n    \"parts\": [\n      {\n        \"is_final\": false,\n        \"number\": 1,\n        \"size\": 10568125\n      }\n    ]\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Request non-final part
require 'uri'
require 'net/http'

url = URI("https://api.frame.io/v2/devices/assets/:asset_id/realtime_upload/parts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"body\": {\n    \"parts\": [\n      {\n        \"is_final\": false,\n        \"number\": 1,\n        \"size\": 10568125\n      }\n    ]\n  }\n}"

response = http.request(request)
puts response.read_body
```

```java Request non-final part
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.frame.io/v2/devices/assets/:asset_id/realtime_upload/parts")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"body\": {\n    \"parts\": [\n      {\n        \"is_final\": false,\n        \"number\": 1,\n        \"size\": 10568125\n      }\n    ]\n  }\n}")
  .asString();
```

```php Request non-final part
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.frame.io/v2/devices/assets/:asset_id/realtime_upload/parts', [
  'body' => '{
  "body": {
    "parts": [
      {
        "is_final": false,
        "number": 1,
        "size": 10568125
      }
    ]
  }
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Request non-final part
using RestSharp;

var client = new RestClient("https://api.frame.io/v2/devices/assets/:asset_id/realtime_upload/parts");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"body\": {\n    \"parts\": [\n      {\n        \"is_final\": false,\n        \"number\": 1,\n        \"size\": 10568125\n      }\n    ]\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Request non-final part
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["body": ["parts": [
      [
        "is_final": false,
        "number": 1,
        "size": 10568125
      ]
    ]]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.frame.io/v2/devices/assets/:asset_id/realtime_upload/parts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Request final part with filesize

**Request**

```json
{
  "body": {
    "asset_filesize": 21136250,
    "parts": [
      {
        "is_final": true,
        "number": 2,
        "size": 10568125
      }
    ]
  }
}
```

**SDK Code**

```typescript Request final part with filesize
const response = await fetch('https://api.frame.io/v2/devices/assets/{asset_id}/realtime_upload/parts', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer [access_token]',
    'Content-Type': 'application/json',
    'x-client-version': '2.0.0'
  },
  body: JSON.stringify({
    asset_filesize: 21136250,
    parts: [
      {
        number: 2,
        size: 10568125,
        is_final: true
      }
    ]
  })
});

const result = await response.json();
console.log(result);
```

```python Request final part with filesize
import requests

headers = {
    'Authorization': 'Bearer [access_token]',
    'Content-Type': 'application/json',
    'x-client-version': '2.0.0'
}

data = {
    'asset_filesize': 21136250,
    'parts': [
        {
            'number': 2,
            'size': 10568125,
            'is_final': True
        }
    ]
}

response = requests.post(
    'https://api.frame.io/v2/devices/assets/{asset_id}/realtime_upload/parts',
    headers=headers,
    json=data
)

result = response.json()
print(result)
```

```go Request final part with filesize
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.frame.io/v2/devices/assets/:asset_id/realtime_upload/parts"

	payload := strings.NewReader("{\n  \"body\": {\n    \"asset_filesize\": 21136250,\n    \"parts\": [\n      {\n        \"is_final\": true,\n        \"number\": 2,\n        \"size\": 10568125\n      }\n    ]\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Request final part with filesize
require 'uri'
require 'net/http'

url = URI("https://api.frame.io/v2/devices/assets/:asset_id/realtime_upload/parts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"body\": {\n    \"asset_filesize\": 21136250,\n    \"parts\": [\n      {\n        \"is_final\": true,\n        \"number\": 2,\n        \"size\": 10568125\n      }\n    ]\n  }\n}"

response = http.request(request)
puts response.read_body
```

```java Request final part with filesize
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.frame.io/v2/devices/assets/:asset_id/realtime_upload/parts")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"body\": {\n    \"asset_filesize\": 21136250,\n    \"parts\": [\n      {\n        \"is_final\": true,\n        \"number\": 2,\n        \"size\": 10568125\n      }\n    ]\n  }\n}")
  .asString();
```

```php Request final part with filesize
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.frame.io/v2/devices/assets/:asset_id/realtime_upload/parts', [
  'body' => '{
  "body": {
    "asset_filesize": 21136250,
    "parts": [
      {
        "is_final": true,
        "number": 2,
        "size": 10568125
      }
    ]
  }
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Request final part with filesize
using RestSharp;

var client = new RestClient("https://api.frame.io/v2/devices/assets/:asset_id/realtime_upload/parts");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"body\": {\n    \"asset_filesize\": 21136250,\n    \"parts\": [\n      {\n        \"is_final\": true,\n        \"number\": 2,\n        \"size\": 10568125\n      }\n    ]\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Request final part with filesize
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["body": [
    "asset_filesize": 21136250,
    "parts": [
      [
        "is_final": true,
        "number": 2,
        "size": 10568125
      ]
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.frame.io/v2/devices/assets/:asset_id/realtime_upload/parts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```