Start recording

Start recording a stream.

Stream will be recorded and automatically saved in our video hosting as a separate video VOD:

• ID of the stream from which the recording was organized is added to “stream_id” field. You can find the video by that value later.
• Title of the video is based on pattern “Stream Record: , ”.
• Recording start time is stored in “recording_started_at” field.
• You can record the original stream or the transcoded one. Only the transcoded version will contain overlays. Set the appropriate recording method when creating the stream or before calling this recording method. Details in the “record_type” parameter of the stream.
• If you have access to the premium feature of saving the original stream (so not just transcoded renditions), then the link to the original file will be in the “origin_url” field. The original file is stored for up to 7 days and is then deleted automatically. By default, custom retention for original recorded files is not available. For enterprise customers, this retention policy can be adjusted individually upon request. Look at the description of the field how to use it.

Stream must be live for the recording to start, please check fields “live” and/or “backup_live”. After the recording starts, field “recording” will switch to “true”, and the recording duration in seconds will appear in the “recording_duration” field.

Please, keep in mind that recording doesn’t start instantly, it takes ±3-7 seconds to initialize the process after executing this method.

Stream recording stops when:

• Explicit execution of the method /stop_recording. In this case, the file will be completely saved and closed. When you execute the stream recording method again, the recording will be made to a new video file.

• When sending the stream stops on the client side, or stops accidentally. In this case, recording process is waiting for 10 seconds to resume recording:

• If the stream resumes within that period, recording will continue to the same file.

• After that period, the file will be completely saved and closed.

• If the stream suddenly resumes after this period, the recording will go to a new file, because old file is closed already. Please, also note that if you have long broadcasts, the recording will be cut into 4-hour videos. This value is fixed, but can be changed upon request to the Support Team.

PUT /streaming/streams/{stream_id}/start_recording

Start recording

cURL

curl --request PUT \
  --url https://api.gcore.com/streaming/streams/{stream_id}/start_recording \
  --header 'Authorization: <api-key>'

import requests

url = "https://api.gcore.com/streaming/streams/{stream_id}/start_recording"

headers = {"Authorization": "<api-key>"}

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

print(response.text)

const options = {method: 'PUT', headers: {Authorization: '<api-key>'}};

fetch('https://api.gcore.com/streaming/streams/{stream_id}/start_recording', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.gcore.com/streaming/streams/{stream_id}/start_recording",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "Authorization: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

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

func main() {

	url := "https://api.gcore.com/streaming/streams/{stream_id}/start_recording"

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

	req.Header.Add("Authorization", "<api-key>")

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

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

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.put("https://api.gcore.com/streaming/streams/{stream_id}/start_recording")
  .header("Authorization", "<api-key>")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.gcore.com/streaming/streams/{stream_id}/start_recording")

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

request = Net::HTTP::Put.new(url)
request["Authorization"] = '<api-key>'

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

200

{
  "data": {
    "stream": {
      "id": 123,
      "client": {
        "id": 777,
        "storage_usage_mb": 2048,
        "storage_limit_mb": 10240
      }
    }
  },
  "warnings": [
    {
      "key": "client_storage_almost_exceeded",
      "source_object": {
        "id": 918,
        "type": "client"
      },
      "meta": {
        "storage_usage_mb": 1200,
        "storage_limit_mb": 2048
      }
    }
  ],
  "errors": [
    {}
  ]
}

{
  "status": 404,
  "error": "Not Found. Entity you are looking for was not found, please check the initial parameters"
}

Authorizations

Authorization · string · header · required

API key for authentication. Make sure to include the word apikey, followed by a single space and then your token. Example: apikey 1234$abcdef

Path Parameters

stream_id · integer · required

ID of a stream to record

Response

200

application/json

Recording task was set successfully, but there are some actions you need to pay attention

data · object

Stream data

Show child attributes

warnings · object[]

List of warnings received on starting recording process

Show child attributes

errors · object[]

List of errors received on attempt to start recording process