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

# Update a simulcast

PUT https://api.fastpix.com/v1/live/streams/{streamId}/simulcast/{simulcastId}
Content-Type: application/json

Updates the status of a specific simulcast linked to a parent live stream. You can enable or disable the simulcast at any time while the parent stream is active or idle. After the live stream is disabled, the simulcast can no longer be modified.

Webhook event: video.live\_stream.simulcast\_target.updated

#### Example

When a `PATCH` request is made to this endpoint, the API updates the status of the simulcast. This can be useful for pausing or resuming a simulcast on a particular platform without stopping the parent live stream.

Reference: https://fastpix.com/docs/live-stream-api/simulcast-stream/update-specific-simulcast-of-stream

## Authentication

- `Authorization` header (basic auth, required) — FastPix APIs are secured with Basic Authentication. Use your Access Token ID as the username and Secret Key as the password in the Authorization header of each API request. * Username: Access Token ID * Password: Secret Key Activate your FastPix account to generate your API credentials. See the guide here

## Request

### Path parameters

- `streamId` (string, required) — Upon creating a new live stream, FastPix assigns a unique identifier to the stream.
- `simulcastId` (string, required) — When you create the new simulcast, FastPix assign a universal unique identifier which can contain a maximum of 255 characters.

### Body (application/json)

This endpoint expects a simulcastUpdateRequest.

- `isEnabled` (boolean, optional, default: true) — When set to false, the simulcast is disabled for the specified stream.
- `metadata` (map from string to string, optional) — You can search for videos with specific key-value pairs using metadata, when you tag a video in "key":"value" pairs.

## Response

### 200

Stream's simulcast details fetched successfully

- `success` (boolean, optional) — Shows the request status. Returns true for success and false for failure.
- `data` (SimulcastUpdateResponseData, optional) — Displays the result of the request.

## Types

### SimulcastUpdateResponseData

Displays the result of the request.

- `simulcastId` (string, optional) — When you create the new simulcast, FastPix assign a universal unique identifier which can contain a maximum of 255 characters.
- `url` (string, optional) — The RTMP hostname, combined with the application name, is crucial for connecting to third-party live streaming services and transmitting the live stream.
- `streamKey` (string, optional) — A unique stream key is generated for streaming, allowing the user to start streaming on any third-party platform using this key.
- `isEnabled` (boolean, optional) — When set to false, the simulcast is disabled for the specified stream.
- `metadata` (map from string to string, optional) — You can search for videos with specific key value pairs using metadata, when you tag a video in "key":"value"s pairs. Dynamic metadata allows you to define a key that allows any value pair. You can have maximum of 255 characters and upto 10 entries are allowed.

## Examples

**Request**

```json
{
  "isEnabled": true,
  "metadata": {
    "simulcast_name": "Tech today"
  }
}
```

**Response**

```json
{
  "success": true,
  "data": {
    "simulcastId": "8717422d89288ad5958d4a86e9afe2a2",
    "url": "rtmp://hyd01.contribute.live-video.net/app/",
    "streamKey": "live_1012464221_DuM8W004MoZYNxQEZ0czODgfHCFBhk",
    "isEnabled": false,
    "metadata": {
      "simulcast_name": "Tech today"
    }
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.fastpix.com/v1/live/streams/9714422d89287ad5758d4a86e9afe1a2/simulcast/8717422d89288ad5958d4a86e9afe2a2"

payload = {
    "isEnabled": True,
    "metadata": { "simulcast_name": "Tech today" }
}
headers = {
    "Content-Type": "application/json"
}

response = requests.put(url, json=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript
const url = 'https://api.fastpix.com/v1/live/streams/9714422d89287ad5758d4a86e9afe1a2/simulcast/8717422d89288ad5958d4a86e9afe2a2';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'PUT',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"isEnabled":true,"metadata":{"simulcast_name":"Tech today"}}'
};

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

```go
package main

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

func main() {

	url := "https://api.fastpix.com/v1/live/streams/9714422d89287ad5758d4a86e9afe1a2/simulcast/8717422d89288ad5958d4a86e9afe2a2"

	payload := strings.NewReader("{\n  \"isEnabled\": true,\n  \"metadata\": {\n    \"simulcast_name\": \"Tech today\"\n  }\n}")

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

	req.SetBasicAuth("<username>", "<password>")
	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
require 'uri'
require 'net/http'

url = URI("https://api.fastpix.com/v1/live/streams/9714422d89287ad5758d4a86e9afe1a2/simulcast/8717422d89288ad5958d4a86e9afe2a2")

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

request = Net::HTTP::Put.new(url)
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"isEnabled\": true,\n  \"metadata\": {\n    \"simulcast_name\": \"Tech today\"\n  }\n}"

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

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

HttpResponse<String> response = Unirest.put("https://api.fastpix.com/v1/live/streams/9714422d89287ad5758d4a86e9afe1a2/simulcast/8717422d89288ad5958d4a86e9afe2a2")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/json")
  .body("{\n  \"isEnabled\": true,\n  \"metadata\": {\n    \"simulcast_name\": \"Tech today\"\n  }\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.fastpix.com/v1/live/streams/9714422d89287ad5758d4a86e9afe1a2/simulcast/8717422d89288ad5958d4a86e9afe2a2', [
  'body' => '{
  "isEnabled": true,
  "metadata": {
    "simulcast_name": "Tech today"
  }
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    'auth' => ['<username>', '<password>'],
]);

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

```csharp
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://api.fastpix.com/v1/live/streams/9714422d89287ad5758d4a86e9afe1a2/simulcast/8717422d89288ad5958d4a86e9afe2a2");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.PUT);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"isEnabled\": true,\n  \"metadata\": {\n    \"simulcast_name\": \"Tech today\"\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = [
  "isEnabled": true,
  "metadata": ["simulcast_name": "Tech today"]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fastpix.com/v1/live/streams/9714422d89287ad5758d4a86e9afe1a2/simulcast/8717422d89288ad5958d4a86e9afe2a2")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```