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

# Request upload URLs for real-time upload

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

Register real-time upload parts and generate presigned AWS S3 upload PUT URLs.

Reference: https://next.developer.frame.io/platform/v2/api-reference/assets/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

### Body (application/json)

This endpoint expects an object.

- `parts` (list of V2AssetsAssetIdRealtimeUploadPartsPostRequestBodyContentApplicationJsonSchemaPartsItems, 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

### V2AssetsAssetIdRealtimeUploadPartsPostRequestBodyContentApplicationJsonSchemaPartsItems

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

### Basic

**Response**

```json
{
  "upload_urls": [
    "https://frameio-uploads-production.s3-accelerate.amazonaws.com/parts/[part_02_path]"
  ]
}
```

**SDK Code**

```python Basic
import requests

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

headers = {"Authorization": "Bearer <token>"}

response = requests.post(url, headers=headers)

print(response.json())
```

```javascript Basic
const url = 'https://api.frame.io/v2/assets/asset_id/realtime_upload/parts';
const options = {method: 'POST', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Basic
package main

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

func main() {

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

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby Basic
require 'uri'
require 'net/http'

url = URI("https://api.frame.io/v2/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>'

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

```java Basic
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.frame.io/v2/assets/asset_id/realtime_upload/parts")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Basic
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.frame.io/v2/assets/asset_id/realtime_upload/parts', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Basic
using RestSharp;

var client = new RestClient("https://api.frame.io/v2/assets/asset_id/realtime_upload/parts");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Basic
import Foundation

let headers = ["Authorization": "Bearer <token>"]

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

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 URL for non-final part

**Request**

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

**Response**

```json
{
  "upload_urls": [
    "https://frameio-uploads-production.s3-accelerate.amazonaws.com/parts/[part_02_path]"
  ]
}
```

**SDK Code**

```python Request URL for non-final part
import requests

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

payload = { "parts": [
        {
            "number": 1,
            "size": 10568125,
            "is_final": False
        }
    ] }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Request URL for non-final part
const url = 'https://api.frame.io/v2/assets/asset_id/realtime_upload/parts';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"parts":[{"number":1,"size":10568125,"is_final":false}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Request URL for non-final part
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"parts\": [\n    {\n      \"number\": 1,\n      \"size\": 10568125,\n      \"is_final\": false\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 URL for non-final part
require 'uri'
require 'net/http'

url = URI("https://api.frame.io/v2/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  \"parts\": [\n    {\n      \"number\": 1,\n      \"size\": 10568125,\n      \"is_final\": false\n    }\n  ]\n}"

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

```java Request URL for 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/assets/asset_id/realtime_upload/parts")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"parts\": [\n    {\n      \"number\": 1,\n      \"size\": 10568125,\n      \"is_final\": false\n    }\n  ]\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

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

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

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

var client = new RestClient("https://api.frame.io/v2/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  \"parts\": [\n    {\n      \"number\": 1,\n      \"size\": 10568125,\n      \"is_final\": false\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Request URL for non-final part
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.frame.io/v2/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 URL for final part with filesize

**Request**

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

**Response**

```json
{
  "upload_urls": [
    "https://frameio-uploads-production.s3-accelerate.amazonaws.com/parts/[part_02_path]"
  ]
}
```

**SDK Code**

```python Request URL for final part with filesize
import requests

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

payload = {
    "parts": [
        {
            "number": 2,
            "size": 10568125,
            "is_final": True
        }
    ],
    "asset_filesize": 21136250
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Request URL for final part with filesize
const url = 'https://api.frame.io/v2/assets/asset_id/realtime_upload/parts';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"parts":[{"number":2,"size":10568125,"is_final":true}],"asset_filesize":21136250}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Request URL for final part with filesize
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"parts\": [\n    {\n      \"number\": 2,\n      \"size\": 10568125,\n      \"is_final\": true\n    }\n  ],\n  \"asset_filesize\": 21136250\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 URL for final part with filesize
require 'uri'
require 'net/http'

url = URI("https://api.frame.io/v2/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  \"parts\": [\n    {\n      \"number\": 2,\n      \"size\": 10568125,\n      \"is_final\": true\n    }\n  ],\n  \"asset_filesize\": 21136250\n}"

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

```java Request URL for 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/assets/asset_id/realtime_upload/parts")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"parts\": [\n    {\n      \"number\": 2,\n      \"size\": 10568125,\n      \"is_final\": true\n    }\n  ],\n  \"asset_filesize\": 21136250\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

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

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

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

var client = new RestClient("https://api.frame.io/v2/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  \"parts\": [\n    {\n      \"number\": 2,\n      \"size\": 10568125,\n      \"is_final\": true\n    }\n  ],\n  \"asset_filesize\": 21136250\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Request URL for final part with filesize
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.frame.io/v2/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 asset name update

**Request**

```json
{
  "parts": [
    {
      "number": 2,
      "size": 10568125,
      "is_final": true
    }
  ],
  "asset_name": "C2C_TEST_CLIP.mp4",
  "asset_filesize": 21136250
}
```

**Response**

```json
{
  "upload_urls": [
    "https://frameio-uploads-production.s3-accelerate.amazonaws.com/parts/[part_02_path]"
  ]
}
```

**SDK Code**

```python Request final part with asset name update
import requests

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

payload = {
    "parts": [
        {
            "number": 2,
            "size": 10568125,
            "is_final": True
        }
    ],
    "asset_name": "C2C_TEST_CLIP.mp4",
    "asset_filesize": 21136250
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Request final part with asset name update
const url = 'https://api.frame.io/v2/assets/asset_id/realtime_upload/parts';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"parts":[{"number":2,"size":10568125,"is_final":true}],"asset_name":"C2C_TEST_CLIP.mp4","asset_filesize":21136250}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Request final part with asset name update
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"parts\": [\n    {\n      \"number\": 2,\n      \"size\": 10568125,\n      \"is_final\": true\n    }\n  ],\n  \"asset_name\": \"C2C_TEST_CLIP.mp4\",\n  \"asset_filesize\": 21136250\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 asset name update
require 'uri'
require 'net/http'

url = URI("https://api.frame.io/v2/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  \"parts\": [\n    {\n      \"number\": 2,\n      \"size\": 10568125,\n      \"is_final\": true\n    }\n  ],\n  \"asset_name\": \"C2C_TEST_CLIP.mp4\",\n  \"asset_filesize\": 21136250\n}"

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

```java Request final part with asset name update
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

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

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

$client = new \GuzzleHttp\Client();

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

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

```csharp Request final part with asset name update
using RestSharp;

var client = new RestClient("https://api.frame.io/v2/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  \"parts\": [\n    {\n      \"number\": 2,\n      \"size\": 10568125,\n      \"is_final\": true\n    }\n  ],\n  \"asset_name\": \"C2C_TEST_CLIP.mp4\",\n  \"asset_filesize\": 21136250\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Request final part with asset name update
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.frame.io/v2/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()
```