> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gcore.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Create restream

> Creates a new restream for a specified live stream.
  


Specify the target platform's URI (RTMP, RTMPS, or SRT) and the ID of the source stream.
  


Restreaming allows you to broadcast a single live stream to multiple platforms or servers simultaneously (e.g., Facebook, YouTube, or a custom media server).

**How it works:**
1. Get credentials (stream URL/key or SRT URL) from the target platform.
2. Create a restream in the Gcore system by specifying the target URI and the source live stream.
3. Start your live stream; it will be automatically pushed to the target destination.

```text
                +-----------------------+
RTMP/RTMPS      |                       | -------->  Facebook (RTMP)
    or  ------> |    Gcore Streaming    | -------->  YouTube (RTMPS)
SRT             |                       | -------->  Media server (SRT)
                +-----------------------+ -------->  Other RTMP/SRT targets
```

**Supported combinations:** RTMP → RTMP, RTMPS → RTMPS, RTMP → SRT, SRT → SRT, SRT → RTMP.
For SRT targets, only `mode=caller` is supported (Gcore initiates a PUSH connection).
  


Source stream parameters (bitrate, codecs, resolution) are sent "as is". Ensure they match the destination requirements.

  


For **SRT restreams**, specify `&latency=N` explicitly in the SRT target URL instead of relying on a default value. It helps size the recovery buffer for round-trip time, jitter, and packet loss on the route to the target site.
Selecting the right latency is crucial for delivering a smooth live stream. It depends on the geographic distance and network conditions between Gcore and your target platform, especially if they located on different continents.

```text
| Network Conditions      | Recommended Latency |
|-------------------------|---------------------|
| Cross-region            | 1-2 seconds         |
| Public internet         | 2-5 seconds         |
```

Your target SRT server can accept latency format in seconds, milliseconds, or microseconds. Find out what format your target SRT server accepts in its documentation.

Learn more about SRT latency in product documentation.



## OpenAPI

````yaml /api-reference/services_docs_mintlify/streaming_api.yaml post /streaming/restreams
openapi: 3.1.0
info:
  title: Gcore OpenAPI – Streaming API
  description: >-
    This OpenAPI is an aggregated OpenAPI specification that unifies all Gcore
    products into a single file. It covers Cloud, CDN, DNS, WAAP, DDoS
    Protection, Object Storage, Streaming, and FastEdge services.
  version: a41613cd4a9e
servers:
  - url: https://api.gcore.com
security:
  - APIKey: []
tags:
  - name: AI
  - name: Broadcasts
  - name: Directories
  - name: Overlays
  - name: Players
  - name: Playlists
  - name: QualitySets
  - name: Restreams
  - name: Statistics
  - name: Streams
  - name: Subtitles
  - name: Videos
paths:
  /streaming/restreams:
    post:
      tags:
        - Restreams
      summary: Create restream
      description: >-
        Creates a new restream for a specified live stream.
          


        Specify the target platform's URI (RTMP, RTMPS, or SRT) and the ID of
        the source stream.
          


        Restreaming allows you to broadcast a single live stream to multiple
        platforms or servers simultaneously (e.g., Facebook, YouTube, or a
        custom media server).


        **How it works:**

        1. Get credentials (stream URL/key or SRT URL) from the target platform.

        2. Create a restream in the Gcore system by specifying the target URI
        and the source live stream.

        3. Start your live stream; it will be automatically pushed to the target
        destination.


        ```text
                        +-----------------------+
        RTMP/RTMPS      |                       | -------->  Facebook (RTMP)
            or  ------> |    Gcore Streaming    | -------->  YouTube (RTMPS)
        SRT             |                       | -------->  Media server (SRT)
                        +-----------------------+ -------->  Other RTMP/SRT targets
        ```


        **Supported combinations:** RTMP → RTMP, RTMPS → RTMPS, RTMP → SRT, SRT
        → SRT, SRT → RTMP.

        For SRT targets, only `mode=caller` is supported (Gcore initiates a PUSH
        connection).
          


        Source stream parameters (bitrate, codecs, resolution) are sent "as is".
        Ensure they match the destination requirements.

          


        For **SRT restreams**, specify `&latency=N` explicitly in the SRT target
        URL instead of relying on a default value. It helps size the recovery
        buffer for round-trip time, jitter, and packet loss on the route to the
        target site.

        Selecting the right latency is crucial for delivering a smooth live
        stream. It depends on the geographic distance and network conditions
        between Gcore and your target platform, especially if they located on
        different continents.


        ```text

        | Network Conditions      | Recommended Latency |

        |-------------------------|---------------------|

        | Cross-region            | 1-2 seconds         |

        | Public internet         | 2-5 seconds         |

        ```


        Your target SRT server can accept latency format in seconds,
        milliseconds, or microseconds. Find out what format your target SRT
        server accepts in its documentation.


        Learn more about SRT latency in product documentation.
      operationId: post_restreams
      parameters: []
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                restream:
                  $ref: '#/components/schemas/createRestream'
        required: false
      responses:
        '200':
          description: Successful
          content: {}
        '422':
          description: |-
            Possible error messages:   
             **{ "errors": { "stream": [ "must exist" ] } }**   
             A required parameter *`stream_id`* wasn't specified or a stream with such ID hasn't been created.   
             **{ "errors": { "stream": [ "does not belong to the same client " ] } }**   
             A stream with specified ID belongs to another client. **{ "errors": { "uri": [ "invalid uri, supported protocols are rtmp, rtmps, srt" ] } }**   
             A required parameter *uri* wasn't specified or the input protocol is not supported
          content: {}
components:
  schemas:
    createRestream:
      type: object
      properties:
        name:
          type: string
          description: Restream name
        live:
          type: boolean
          description: >-
            Indicates that the stream is being published. Has two possible
            values:


            - **true** — stream is being published

            - **false** — stream isn't published
        active:
          type: boolean
          description: |-
            Enables/Disables restream. Has two possible values:

            - **true** — restream is enabled and can be started
            - **false** — restream is disabled.

              
            Default is true
        uri:
          type: string
          description: >-
            A URL to push the stream to. Supported protocols: rtmp, rtmps, srt.
            For SRT target URLs, only `mode=caller` is supported.
          example: srt://example.com:1234?mode=caller
        stream_id:
          type: integer
          description: ID of the stream to restream
        client_user_id:
          type: integer
          description: Custom field where you can specify user ID in your system
      example:
        name: first restream
        active: true
        uri: rtmp://a.rtmp.youtube.com/live/k17a-13s8
        stream_id: 20
        client_user_id: 10
  securitySchemes:
    APIKey:
      description: >-
        API key for authentication. Make sure to include the word `apikey`,
        followed by a single space and then your token.

        Example: `apikey 1234$abcdef`
      type: apiKey
      in: header
      name: Authorization

````