Ingress API

{
    "input_type": 0 for RTMP, 1 for WHIP
    "name": "Name of the ingress goes here",
    "room_name": "Name of the room to connect to",
    "participant_identity": "Unique identity for the room participant the Ingress service will connect as",
    "participant_name": "Name displayed in the room for the participant",
    "enable_transcoding": true // Transcode the input stream. Can only be false for WHIP,
}

export LIVEKIT_URL=https://my-livekit-host
export LIVEKIT_API_KEY=livekit-api-key
export LIVEKIT_API_SECRET=livekit-api-secret

lk ingress create ingress.json

import { LiveKitAPI, IngressInput } from 'livekit-server-sdk';

const api = new LiveKitAPI();

const ingress = {
  name: 'my-ingress',
  roomName: 'my-room',
  participantIdentity: 'my-participant',
  participantName: 'My Participant',
  // Transcode the input stream. Can only be false for WHIP.
  enableTranscoding: false,
};

// Use IngressInput.WHIP_INPUT to create a WHIP endpoint
const info = await api.ingress.createIngress(IngressInput.RTMP_INPUT, ingress);

from livekit import api

async with api.LiveKitAPI() as lkapi:
    info = await lkapi.ingress.create_ingress(
        api.CreateIngressRequest(
            input_type=api.IngressInput.RTMP_INPUT,  # or api.IngressInput.WHIP_INPUT
            name="my-ingress",
            room_name="my-room",
            participant_identity="my-participant",
            participant_name="My Participant",
            # Transcode the input stream. Can only be false for WHIP.
            enable_transcoding=True,
        )
    )
    print(info.ingress_id)

require 'livekit'

lkapi = LiveKit::LiveKitAPI.new
info = lkapi.ingress.create_ingress(
  :RTMP_INPUT, # Or WHIP_INPUT
  name: "my-ingress",
  room_name: "my-room",
  participant_identity: "my-participant",
  participant_name: "My Participant",
  enable_transcoding: true
)
puts info.ingress_id

import lksdk "github.com/livekit/server-sdk-go/v2"

ctx := context.Background()
api, err := lksdk.NewLiveKitAPI()

t := true

ingressRequest := &livekit.CreateIngressRequest{
    InputType:           livekit.IngressInput_RTMP_INPUT, // Or livekit.IngressInput_WHIP_INPUT
    Name:                "my-ingress",
    RoomName:            "my-room",
    ParticipantIdentity: "my-participant",
    ParticipantName:     "My Participant",
    // Transcode the input stream. Can only be false for WHIP.
    EnableTranscoding: &t,
}

info, err := api.Ingress().CreateIngress(ctx, ingressRequest)
ingressID := info.IngressId

import io.livekit.server.LiveKitAPI
import livekit.LivekitIngress

val api = LiveKitAPI.createClient(host, apiKey, secret)
val info = api.ingress.createIngress(
    "my-ingress",
    roomName = "my-room",
    participantIdentity = "my-participant",
    participantName = "My Participant",
    // Or LivekitIngress.IngressInput.WHIP_INPUT
    inputType = LivekitIngress.IngressInput.RTMP_INPUT,
    // Transcode the input stream. Can only be false for WHIP.
    enableTranscoding = true,
).execute().body()

use livekit_api::services::ingress::CreateIngressOptions;
use livekit_api::services::LiveKitApi;
use livekit_protocol as proto;

let api = LiveKitApi::with_api_key(host, api_key, api_secret);
let info = api
    .ingress()
    .create_ingress(
        proto::IngressInput::RtmpInput, // or proto::IngressInput::WhipInput
        CreateIngressOptions {
            name: "my-ingress".to_string(),
            room_name: "my-room".to_string(),
            participant_identity: "my-participant".to_string(),
            participant_name: "My Participant".to_string(),
            // Transcode the input stream. Can only be false for WHIP.
            enable_transcoding: Some(true),
            ..Default::default()
        },
    )
    .await?;

{
  "input_type": "URL_INPUT", // or 2
  "name": "Name of the ingress goes here",
  "room_name": "Name of the room to connect to",
  "participant_identity": "Unique identity for the room participant the Ingress service will connect as",
  "participant_name": "Name displayed in the room for the participant",
  "url": "HTTP(S) or SRT url to the file or stream"
}

export LIVEKIT_URL=https://my-livekit-host
export LIVEKIT_API_KEY=livekit-api-key
export LIVEKIT_API_SECRET=livekit-api-secret

lk ingress create ingress.json

import { LiveKitAPI, IngressInput } from 'livekit-server-sdk';

const api = new LiveKitAPI();

const ingress = {
  name: 'my-ingress',
  roomName: 'my-room',
  participantIdentity: 'my-participant',
  participantName: 'My Participant',
  url: 'https://domain.com/video.m3u8', // or 'srt://domain.com:7001'
};

const info = await api.ingress.createIngress(IngressInput.URL_INPUT, ingress);

from livekit import api

async with api.LiveKitAPI() as lkapi:
    info = await lkapi.ingress.create_ingress(
        api.CreateIngressRequest(
            input_type=api.IngressInput.URL_INPUT,
            name="my-ingress",
            room_name="my-room",
            participant_identity="my-participant",
            participant_name="My Participant",
            url="https://domain.com/video.m3u8",  # or 'srt://domain.com:7001'
        )
    )
    print(info.ingress_id)

require 'livekit'

lkapi = LiveKit::LiveKitAPI.new
info = lkapi.ingress.create_ingress(
  :URL_INPUT,
  name: "my-ingress",
  room_name: "my-room",
  participant_identity: "my-participant",
  participant_name: "My Participant",
  url: "https://domain.com/video.m3u8", # or 'srt://domain.com:7001'
)
puts info.ingress_id

import lksdk "github.com/livekit/server-sdk-go/v2"

ctx := context.Background()
api, err := lksdk.NewLiveKitAPI()

ingressRequest := &livekit.CreateIngressRequest{
    InputType:           livekit.IngressInput_URL_INPUT,
    Name:                "my-ingress",
    RoomName:            "my-room",
    ParticipantIdentity: "my-participant",
    ParticipantName:     "My Participant",
    Url:                 "https://domain.com/video.m3u8", // or 'srt://domain.com:7001'
}

info, err := api.Ingress().CreateIngress(ctx, ingressRequest)
ingressID := info.IngressId

import io.livekit.server.LiveKitAPI
import livekit.LivekitIngress

val api = LiveKitAPI.createClient(host, apiKey, secret)
val info = api.ingress.createIngress(
    "my-ingress",
    roomName = "my-room",
    participantIdentity = "my-participant",
    participantName = "My Participant",
    inputType = LivekitIngress.IngressInput.URL_INPUT,
    url = "https://domain.com/video.m3u8", // or "srt://domain.com:7001"
).execute().body()

use livekit_api::services::ingress::CreateIngressOptions;
use livekit_api::services::LiveKitApi;
use livekit_protocol as proto;

let api = LiveKitApi::with_api_key(host, api_key, api_secret);
let info = api
    .ingress()
    .create_ingress(
        proto::IngressInput::UrlInput,
        CreateIngressOptions {
            name: "my-ingress".to_string(),
            room_name: "my-room".to_string(),
            participant_identity: "my-participant".to_string(),
            participant_name: "My Participant".to_string(),
            url: "https://domain.com/video.m3u8".to_string(), // or "srt://domain.com:7001"
            ..Default::default()
        },
    )
    .await?;

lk ingress list

import { LiveKitAPI } from 'livekit-server-sdk';

const api = new LiveKitAPI();
await api.ingress.listIngress({ roomName: 'my-room' });

from livekit import api

async with api.LiveKitAPI() as lkapi:
    # room_name is optional; leave empty to list all Ingress.
    res = await lkapi.ingress.list_ingress(api.ListIngressRequest(room_name="my-room"))

require 'livekit'

lkapi = LiveKit::LiveKitAPI.new
puts lkapi.ingress.list_ingress(
  # optional
  room_name: "my-room"
)

import lksdk "github.com/livekit/server-sdk-go/v2"

api, err := lksdk.NewLiveKitAPI()
listRequest := &livekit.ListIngressRequest{
    RoomName: "my-room", // Optional parameter to restrict the list to only one room. Leave empty to list all Ingress.
}

infoArray, err := api.Ingress().ListIngress(context.Background(), listRequest)

import io.livekit.server.LiveKitAPI

val api = LiveKitAPI.createClient(host, apiKey, secret)
// roomName is optional; leave empty to list all Ingress.
val infos = api.ingress.listIngress(roomName = "my-room").execute().body()

use livekit_api::services::ingress::IngressListFilter;
use livekit_api::services::LiveKitApi;

let api = LiveKitApi::with_api_key(host, api_key, api_secret);
// Use IngressListFilter::All to list every ingress.
let infos = api.ingress().list_ingress(IngressListFilter::Room("my-room".to_string())).await?;

{
  "ingress_id": "Ingress ID of the ingress to update",
  "name": "Name of the ingress goes here",
  "room_name": "Name of the room to connect to",
  "participant_identity": "Unique identity for the room participant the Ingress service will connect as",
  "participant_name": "Name displayed in the room for the participant"
}

lk ingress update ingress.json

import { LiveKitAPI } from 'livekit-server-sdk';

const api = new LiveKitAPI();
const update = {
  name: 'my-other-ingress',
  roomName: 'my-other-room',
  participantIdentity: 'my-other-participant',
  participantName: 'My Other Participant',
};

await api.ingress.updateIngress(ingressId, update);

from livekit import api

async with api.LiveKitAPI() as lkapi:
    # non-specified fields are left unchanged
    info = await lkapi.ingress.update_ingress(
        api.UpdateIngressRequest(
            ingress_id="ingress-id",
            name="my-other-ingress",
            room_name="my-other-room",
            participant_identity="my-other-participant",
            participant_name="My Other Participant",
        )
    )

require 'livekit'

lkapi = LiveKit::LiveKitAPI.new
# only specified fields are updated, all fields are optional
puts lkapi.ingress.update_ingress(
  "ingress-id",
  name: "ingress-name",
  room_name: "my-room",
  participant_identity: "my-participant",
  participant_name: "My Participant"
)

import lksdk "github.com/livekit/server-sdk-go/v2"

api, err := lksdk.NewLiveKitAPI()
updateRequest := &livekit.UpdateIngressRequest{
    IngressId:           "ingressID", // required parameter indicating what Ingress to update
    Name:                "my-other-ingress",
    RoomName:            "my-other-room",
    ParticipantIdentity: "my-other-participant",
    ParticipantName:     "My Other Participant",
}

info, err := api.Ingress().UpdateIngress(context.Background(), updateRequest)

import io.livekit.server.LiveKitAPI

val api = LiveKitAPI.createClient(host, apiKey, secret)
// non-specified fields are left unchanged
val info = api.ingress.updateIngress(
    "ingress-id",
    name = "my-other-ingress",
    roomName = "my-other-room",
    participantIdentity = "my-other-participant",
    participantName = "My Other Participant",
).execute().body()

use livekit_api::services::ingress::UpdateIngressOptions;
use livekit_api::services::LiveKitApi;

let api = LiveKitApi::with_api_key(host, api_key, api_secret);
let info = api
    .ingress()
    .update_ingress(
        "ingress-id",
        UpdateIngressOptions {
            name: "my-other-ingress".to_string(),
            room_name: "my-other-room".to_string(),
            participant_identity: "my-other-participant".to_string(),
            participant_name: "My Other Participant".to_string(),
            ..Default::default()
        },
    )
    .await?;

lk ingress delete <INGRESS_ID>

import { LiveKitAPI } from 'livekit-server-sdk';

const api = new LiveKitAPI();
await api.ingress.deleteIngress('ingress-id');

from livekit import api

async with api.LiveKitAPI() as lkapi:
    info = await lkapi.ingress.delete_ingress(
        api.DeleteIngressRequest(ingress_id="ingress-id")
    )

require 'livekit'

lkapi = LiveKit::LiveKitAPI.new
puts lkapi.ingress.delete_ingress("ingress-id")

import lksdk "github.com/livekit/server-sdk-go/v2"

api, err := lksdk.NewLiveKitAPI()
deleteRequest := &livekit.DeleteIngressRequest{
    IngressId: "ingress-id",
}

info, err := api.Ingress().DeleteIngress(context.Background(), deleteRequest)

import io.livekit.server.LiveKitAPI

val api = LiveKitAPI.createClient(host, apiKey, secret)
val info = api.ingress.deleteIngress("ingress-id").execute().body()

use livekit_api::services::LiveKitApi;

let api = LiveKitApi::with_api_key(host, api_key, api_secret);
let info = api.ingress().delete_ingress("ingress-id").await?;