Realtime

Realtime tokens, channels, publish and presence.

1. Overview

Base path: https://api.infrai.cc/v1/realtime

Auth header: Authorization: Bearer $INFRAI_API_KEY

bash

# Call any /v1/realtime capability over raw HTTP — no SDK to install.
# curl:
curl https://api.infrai.cc/v1/realtime/... \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json"

2. Methods (11)

2.1realtime.publish

POST /v1/realtime/publish

Publish an event to a channel.

Parameters

Name	Type	Required	Description
`channel`	`string`	Required	Channel name.
`event`	`string`	Required	Event name. `default: "message"`
`data`	`unknown`	Required	Event payload to publish.
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

{ message_id }

Name	Type	Description
`event_id`	`string`	Unique identifier for this event
`channel`	`string`	Channel name or identifier
`published_at`	`string`	ISO 8601 timestamp when the event was published `format: date-time`
`vendor`	`string`	Vendor that handled or will handle this request

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/realtime/publish \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"channel": "room-42", "event": "message", "data": {"text": "hi"}}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/realtime/publish",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'channel': 'room-42', 'event': 'message', 'data': {'text': 'hi'}},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/publish",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"channel": "room-42", "event": "message", "data": {"text": "hi"}}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/publish",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"channel": "room-42", "event": "message", "data": {"text": "hi"}}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"channel": "room-42", "event": "message", "data": {"text": "hi"}}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/realtime/publish", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/realtime/publish"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"channel\": \"room-42\", \"event\": \"message\", \"data\": {\"text\": \"hi\"}}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/realtime/publish");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"channel\": \"room-42\", \"event\": \"message\", \"data\": {\"text\": \"hi\"}}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/realtime/publish");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"channel\": \"room-42\", \"event\": \"message\", \"data\": {\"text\": \"hi\"}}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/realtime/publish")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"channel": "room-42", "event": "message", "data": {"text": "hi"}}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/realtime/publish")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"channel": "room-42", "event": "message", "data": {"text": "hi"}}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.2realtime.token.issue

POST /v1/realtime/token/issue

Issue a client token scoped to channels and capabilities.

Parameters

Name	Type	Required	Description
`user_id`	`string`	Optional	Id of the connecting user.
`channels`	`string[]`	Optional	Channels the token may access.
`ttl_seconds`	`number`	Optional	Lifetime in seconds before expiry. `≥ 1`

Returns

RealtimeToken { token, client_id, expires_at, endpoint }

Name	Type	Description
`token`	`string`	Authentication or verification token
`jti`	`string`	JWT ID; used for server-side revocation.
`channels`	`string[]`	List of channel names the token grants access to
`capabilities`	`("subscribe" \| "publish" \| "presence" \| "history")[]`	List of capability permissions (publish, subscribe)
`expires_at`	`string`	ISO 8601 timestamp when this resource or token expires `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/realtime/token/issue \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"client_id": "user_42", "channels": ["room-42"], "capabilities": ["subscribe", "presence"], "ttl_seconds": 3600}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/realtime/token/issue",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'client_id': 'user_42', 'channels': ['room-42'], 'capabilities': ['subscribe', 'presence'], 'ttl_seconds': 3600},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/token/issue",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"client_id": "user_42", "channels": ["room-42"], "capabilities": ["subscribe", "presence"], "ttl_seconds": 3600}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/token/issue",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"client_id": "user_42", "channels": ["room-42"], "capabilities": ["subscribe", "presence"], "ttl_seconds": 3600}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"client_id": "user_42", "channels": ["room-42"], "capabilities": ["subscribe", "presence"], "ttl_seconds": 3600}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/realtime/token/issue", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/realtime/token/issue"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"client_id\": \"user_42\", \"channels\": [\"room-42\"], \"capabilities\": [\"subscribe\", \"presence\"], \"ttl_seconds\": 3600}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/realtime/token/issue");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"client_id\": \"user_42\", \"channels\": [\"room-42\"], \"capabilities\": [\"subscribe\", \"presence\"], \"ttl_seconds\": 3600}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/realtime/token/issue");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"client_id\": \"user_42\", \"channels\": [\"room-42\"], \"capabilities\": [\"subscribe\", \"presence\"], \"ttl_seconds\": 3600}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/realtime/token/issue")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"client_id": "user_42", "channels": ["room-42"], "capabilities": ["subscribe", "presence"], "ttl_seconds": 3600}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/realtime/token/issue")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"client_id": "user_42", "channels": ["room-42"], "capabilities": ["subscribe", "presence"], "ttl_seconds": 3600}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.3realtime.channel.create

POST /v1/realtime/channel/create

Create a realtime channel.

Parameters

Name	Type	Required	Description
`name`	`string`	Required	Channel name.
`type`	`"public" \| "private" \| "presence"`	Optional	Channel visibility type. `default: "public"`

Returns

{ channel_id, name, type }

Name	Type	Description
`channel_id`	`string`	Unique identifier for this channel
`name`	`string`	Human-readable name for this resource
`type`	`"public" \| "private" \| "presence"`	Type discriminator for this resource
`vendor`	`string`	Vendor that handled or will handle this request
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`
`member_count`	`integer \| null`	Number of members in the channel `≥ 0`
`last_published_at`	`string \| null`	ISO 8601 timestamp of the last published event `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/realtime/channel/create \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "room-42", "type": "presence"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/realtime/channel/create",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'name': 'room-42', 'type': 'presence'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/create",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"name": "room-42", "type": "presence"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/create",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"name": "room-42", "type": "presence"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"name": "room-42", "type": "presence"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/realtime/channel/create", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/realtime/channel/create"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"name\": \"room-42\", \"type\": \"presence\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/realtime/channel/create");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"name\": \"room-42\", \"type\": \"presence\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/realtime/channel/create");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"name\": \"room-42\", \"type\": \"presence\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/realtime/channel/create")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"name": "room-42", "type": "presence"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/realtime/channel/create")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"name": "room-42", "type": "presence"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.4realtime.presence.get

GET /v1/realtime/presence/get/{channel}

Get the members currently present on a channel.

Parameters

Name	Type	Required	Description
`channel`	`string`	Required	Channel name.

Returns

{ members: Array<{ client_id, user_id? }> }

Name	Type	Description
`channel`	`string`	Channel name or identifier
`members`	`object[]`	List of presence members in the channel
`members[].client_id`	`string`	Client identifier for the connected user
`members[].joined_at`	`string`	ISO 8601 timestamp when this member joined `format: date-time`
`members[].user_data`	`object \| null`	Custom data associated with the presence member
`next_cursor`	`string \| null`	Pass back into presence.get() to fetch the next page; null on last page.

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/realtime/presence/get/CHANNEL \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/realtime/presence/get/CHANNEL",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/presence/get/CHANNEL",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/presence/get/CHANNEL",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/realtime/presence/get/CHANNEL", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/realtime/presence/get/CHANNEL"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/realtime/presence/get/CHANNEL");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/realtime/presence/get/CHANNEL");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/realtime/presence/get/CHANNEL")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/realtime/presence/get/CHANNEL")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.5realtime.channel.get

GET /v1/realtime/channel/get/{channel}

Get the details of a single real-time channel, including type, manufacturer, number of people online, etc.

Parameters

Name	Type	Required	Description
`channel`	`string`	Required	The channel name to be queried.

Returns

Channel { channel_id, name, type, vendor, created_at, member_count?, last_published_at? }

Name	Type	Description
`channel_id`	`string`	Unique identifier for this channel
`name`	`string`	Human-readable name for this resource
`type`	`"public" \| "private" \| "presence"`	Type discriminator for this resource
`vendor`	`string`	Vendor that handled or will handle this request
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`
`member_count`	`integer \| null`	Number of members in the channel `≥ 0`
`last_published_at`	`string \| null`	ISO 8601 timestamp of the last published event `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/realtime/channel/get/CHANNEL \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/realtime/channel/get/CHANNEL",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/get/CHANNEL",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/get/CHANNEL",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/realtime/channel/get/CHANNEL", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/realtime/channel/get/CHANNEL"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/realtime/channel/get/CHANNEL");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/realtime/channel/get/CHANNEL");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/realtime/channel/get/CHANNEL")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/realtime/channel/get/CHANNEL")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.6realtime.channel.delete

DELETE /v1/realtime/channel/delete/{channel}

Delete a live channel and disconnect its subscribers.

Parameters

Name	Type	Required	Description
`channel`	`string`	Required	The name of the channel to be deleted.
`idempotency_key`	`string`	Optional	Idempotent keys for safe retries.

Returns

ChannelDeleteResult { channel, deleted, status }

Name	Type	Description
`channel`	`string`	Channel name or identifier
`deleted`	`boolean`	Whether the resource was successfully deleted
`status`	`"deleted" \| "not_found"`	Current status of this resource

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X DELETE https://api.infrai.cc/v1/realtime/channel/delete/CHANNEL \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.delete(
    "https://api.infrai.cc/v1/realtime/channel/delete/CHANNEL",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/delete/CHANNEL",
  {
    method: "DELETE",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/delete/CHANNEL",
  {
    method: "DELETE",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("DELETE", "https://api.infrai.cc/v1/realtime/channel/delete/CHANNEL", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/realtime/channel/delete/CHANNEL"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("DELETE"), "https://api.infrai.cc/v1/realtime/channel/delete/CHANNEL");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/realtime/channel/delete/CHANNEL");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/realtime/channel/delete/CHANNEL")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .delete("https://api.infrai.cc/v1/realtime/channel/delete/CHANNEL")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.7realtime.channel.list

GET /v1/realtime/channel/list

List the real-time channels under the current account in pages.

Parameters

Name	Type	Required	Description
`cursor`	`string`	Optional	Page turning cursor, pass in the next_cursor returned from the previous page.
`limit`	`number`	Optional	The maximum number of items returned on a single page.

Returns

ChannelListResult { channels: Channel[], next_cursor? }

Name	Type	Description
`channels`	`object[]`	List of channel names the token grants access to
`channels[].channel_id`	`string`	Unique identifier for this channel
`channels[].name`	`string`	Human-readable name for this resource
`channels[].type`	`"public" \| "private" \| "presence"`	Type discriminator for this resource
`channels[].vendor`	`string`	Vendor that handled or will handle this request
`channels[].created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`
`channels[].member_count`	`integer \| null`	Number of members in the channel `≥ 0`
`channels[].last_published_at`	`string \| null`	ISO 8601 timestamp of the last published event `format: date-time`
`next_cursor`	`string \| null`	Pass back into channel.list() to fetch the next page; null on last page.

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/realtime/channel/list \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/realtime/channel/list",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/realtime/channel/list", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/realtime/channel/list"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/realtime/channel/list");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/realtime/channel/list");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/realtime/channel/list")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/realtime/channel/list")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.8realtime.event.types

GET /v1/realtime/event/types

Lists a closed collection of live event types that can be subscribed to.

Returns

EventTypesResult { types: string[] }

Name	Type	Description
`types`	`("channel.opened" \| "channel.closed" \| "message.published" \| "presence.join" \| "presence.leave")[]`	List of available event types

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/realtime/event/types \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/realtime/event/types",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/event/types",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/event/types",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/realtime/event/types", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/realtime/event/types"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/realtime/event/types");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/realtime/event/types");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/realtime/event/types")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/realtime/event/types")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.9realtime.publish.batch

POST /v1/realtime/publish/batch

Bulk publish messages to multiple channels in one call.

Parameters

Name	Type	Required	Description
`messages`	`Array<{ channel: string; event: string; data: unknown }>`	Required	List of messages to publish, each containing channel, event and data. `≥ 1 item`
`idempotency_key`	`string`	Optional	Idempotent keys, used for safe retries to avoid repeated publishing.

Returns

PublishBatchResult { published }

Name	Type	Description
`published`	`integer`	Number of messages accepted for delivery. `≥ 0`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/realtime/publish/batch \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"channel": "sample", "event": "sample", "data": "sample"}]}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/realtime/publish/batch",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'messages': [{'channel': 'sample', 'event': 'sample', 'data': 'sample'}]},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/publish/batch",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"messages": [{"channel": "sample", "event": "sample", "data": "sample"}]}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/publish/batch",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"messages": [{"channel": "sample", "event": "sample", "data": "sample"}]}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"messages": [{"channel": "sample", "event": "sample", "data": "sample"}]}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/realtime/publish/batch", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/realtime/publish/batch"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"messages\": [{\"channel\": \"sample\", \"event\": \"sample\", \"data\": \"sample\"}]}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/realtime/publish/batch");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"messages\": [{\"channel\": \"sample\", \"event\": \"sample\", \"data\": \"sample\"}]}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/realtime/publish/batch");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"messages\": [{\"channel\": \"sample\", \"event\": \"sample\", \"data\": \"sample\"}]}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/realtime/publish/batch")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"messages": [{"channel": "sample", "event": "sample", "data": "sample"}]}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/realtime/publish/batch")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"messages": [{"channel": "sample", "event": "sample", "data": "sample"}]}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.10realtime.token.revoke

POST /v1/realtime/token/revoke

Revoke a previously issued subscription token (used when logging out or banning).

Parameters

Name	Type	Required	Description
`token_or_jti`	`string`	Required	The full token or its jti identifier. `≥ 1 chars`
`idempotency_key`	`string`	Optional	Idempotent keys for safe retries.

Returns

TokenRevokeResult { revoked }

Name	Type	Description
`revoked`	`boolean`	Whether the token was successfully revoked

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/realtime/token/revoke \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"token_or_jti": "sample"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/realtime/token/revoke",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'token_or_jti': 'sample'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/token/revoke",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"token_or_jti": "sample"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/token/revoke",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"token_or_jti": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"token_or_jti": "sample"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/realtime/token/revoke", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/realtime/token/revoke"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"token_or_jti\": \"sample\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/realtime/token/revoke");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"token_or_jti\": \"sample\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/realtime/token/revoke");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"token_or_jti\": \"sample\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/realtime/token/revoke")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"token_or_jti": "sample"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/realtime/token/revoke")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"token_or_jti": "sample"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.11realtime.user.disconnect

POST /v1/realtime/user/disconnect

Force a client to be kicked offline, optionally limited to a single channel.

Parameters

Name	Type	Required	Description
`client_id`	`string`	Required	The client identity to disconnect from. `≥ 1 chars`
`channel`	`string`	Optional	Limit disconnection to this channel; omit to disconnect all.
`idempotency_key`	`string`	Optional	Idempotent keys for safe retries.

Returns

UserDisconnectResult { disconnected }

Name	Type	Description
`disconnected`	`boolean`	Whether the user was successfully disconnected

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/realtime/user/disconnect \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"client_id": "sample"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/realtime/user/disconnect",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'client_id': 'sample'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/user/disconnect",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"client_id": "sample"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/user/disconnect",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"client_id": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"client_id": "sample"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/realtime/user/disconnect", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/realtime/user/disconnect"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"client_id\": \"sample\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/realtime/user/disconnect");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"client_id\": \"sample\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/realtime/user/disconnect");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"client_id\": \"sample\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/realtime/user/disconnect")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"client_id": "sample"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/realtime/user/disconnect")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"client_id": "sample"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

Advanced: pin a vendor

By default infrai routes each call to the best available provider — you do not pick a vendor. As an escape hatch, this capability accepts an optional vendor parameter to pin one specific provider. Every live vendor for this capability is available in real time from the discovery endpoint for the capability id — see the discovery API.

GET /v1/discovery/{capability}

realtime.channel.create

3. All capabilities

Every routed capability in this module — the complete public REST contract. The methods above are the guided walkthrough; this index is the full reference.

realtime.channel.createPOST /v1/realtime/channel/create

Create a realtime pub/sub channel; idempotent.

Parameters (4)

Name	Type	Required	Description
`channel`	`string`	Required	Channel name to create.
`type`	`string`	Optional	Channel type (e.g. public, private, presence). `default: "public"`
`vendor`	`string \| null`	Optional	Pin to a specific fan-out vendor; falls back to the registry default.
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

realtime.channel.deleteDELETE /v1/realtime/channel/delete/{channel}

Delete a realtime channel and disconnect its subscribers.

Parameters (1)

Name	Type	Required	Description
`channel`	`string`	Required	Path parameter.

realtime.channel.getGET /v1/realtime/channel/get/{channel}

Get a single realtime channel's details (type, vendor, online count, etc.).

Parameters (1)

Name	Type	Required	Description
`channel`	`string`	Required	Path parameter.

realtime.channel.listGET /v1/realtime/channel/list

List the account's realtime channels with pagination.

No request parameters.

realtime.event.typesGET /v1/realtime/event/types

List the closed set of subscribable realtime event types.

No request parameters.

realtime.presence.getGET /v1/realtime/presence/get/{channel}

Get the current presence state of members online in a channel.

Parameters (1)

Name	Type	Required	Description
`channel`	`string`	Required	Path parameter.

realtime.publishPOST /v1/realtime/publish

Publish an event message to a realtime pub/sub channel.

Parameters (5)

Name	Type	Required	Description
`channel`	`string`	Required	Channel to publish to.
`event`	`string`	Optional	Event name. `default: "message"`
`data`	`any`	Optional	Event payload (any JSON value).
`account_id`	`string \| null`	Optional	Account identifier that owns this resource
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

realtime.publish.batchPOST /v1/realtime/publish/batch

Publish messages to multiple channels in a single batch call.

Parameters (2)

Name	Type	Required	Description
`messages`	`object[]`	Required	List of messages to publish or process `≥ 1 item`
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

realtime.token.issuePOST /v1/realtime/token/issue

Issue a short-lived infrai-HMAC client auth token for pub/sub realtime channels (NOT for AI voice sessions — see ai.voice.session).

Parameters (5)

Name	Type	Required	Description
`client_id`	`string`	Required	Identity the issued token is bound to. `≥ 1 chars`
`channels`	`string[] \| null`	Optional	Channels the token may attach to; omit for an account-scoped token.
`capabilities`	`("subscribe" \| "publish" \| "presence" \| "history")[] \| null`	Optional	Capability bits; constrained to the RealtimeCapability closed set. Defaults to subscribe.
`ttl_seconds`	`integer \| null`	Optional	Requested lifetime; clamped to MAX_TTL_SECONDS (<=0 or invalid -> REALTIME_TOKEN_TTL_INVALID 400). `≥ 1`
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

realtime.token.revokePOST /v1/realtime/token/revoke

Revoke a previously issued subscription token (e.g., on logout or ban).

Parameters (2)

Name	Type	Required	Description
`token_or_jti`	`string`	Required	Either the full token or its jti. `≥ 1 chars`
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

realtime.user.disconnectPOST /v1/realtime/user/disconnect

Forcibly disconnect a client, optionally scoped to a single channel.

Parameters (3)

Name	Type	Required	Description
`client_id`	`string`	Required	Client identifier for the connected user `≥ 1 chars`
`channel`	`string \| null`	Optional	Restrict the disconnect to this channel; omit for all.
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

4. End-to-end example

A production-style walkthrough of this module: configure once, then run the flow. It exercises most of the module's APIs.

A copy-paste-runnable single-file Python program (stdlib only, no SDK): set your INFRAI_API_KEY, run it, and walk this module's core flow with REAL billed calls — later steps reuse real fields returned by earlier ones. The 12-line helper is the entire integration.

python

#!/usr/bin/env python3
"""Infrai · realtime — runnable real-app example (single file, zero deps).

Copy this file, set your key, run it: every step is a REAL call to
api.infrai.cc, billed at the real (tiny) per-call price, printing the
live JSON response. Get a key at https://infrai.cc/login (Google/
GitHub sign-in grants $2 free credit); add funds at
https://infrai.cc/billing. No SDK — the 12-line helper below is the
entire integration."""
import json
import os
from urllib import error, request

KEY = os.environ.get("INFRAI_API_KEY") or "ifr_..."  # <- your key
BASE = "https://api.infrai.cc"


# Same raw HTTPS POST/GET as every per-method example on this page —
# wrapped once for reuse. There is nothing else to it: no SDK.
def infrai(method, path, body=None):
    req = request.Request(
        BASE + path, method=method,
        data=json.dumps(body).encode() if body is not None else None,
        headers={"Authorization": f"Bearer {KEY}",
                 "Content-Type": "application/json"})
    try:
        with request.urlopen(req, timeout=60) as r:
            return json.loads(r.read())
    except error.HTTPError as e:
        return json.loads(e.read())


def show(label, resp):
    print(f"\n== {label} ==")
    print(json.dumps(resp, indent=2, ensure_ascii=False))
    return resp


# 1) realtime.publish — POST /v1/realtime/publish · Publish an event message to a realtime pub/sub channel.
r1 = show("realtime.publish", infrai("POST", "/v1/realtime/publish", {"channel":"sample"}))

# 2) realtime.token.issue — POST /v1/realtime/token/issue · Issue a short-lived infrai-HMAC client auth token for pub/sub realtime channels.
r2 = show("realtime.token.issue", infrai("POST", "/v1/realtime/token/issue", {"client_id":"sample"}))

# 3) realtime.channel.create — POST /v1/realtime/channel/create · Create a realtime pub/sub channel; idempotent.
r3 = show("realtime.channel.create", infrai("POST", "/v1/realtime/channel/create", {"channel":"sample"}))

# 4) realtime.channel.list — GET /v1/realtime/channel/list · List the account's realtime channels with pagination.
r4 = show("realtime.channel.list", infrai("GET", "/v1/realtime/channel/list"))

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

# 1) Auth: every call is a raw HTTPS request to the Infrai gateway carrying
#    only your project key. No SDK, no install.
#    Get your key: sign in with Google/GitHub at https://infrai.cc/login for a
#    project key + $2 free credit (email sign-in starts at $0). On 402
#    INSUFFICIENT_CREDIT, add funds at https://infrai.cc/billing (or POST
#    /v1/account/topup and open the returned checkout_url).
export INFRAI_API_KEY="ifr_..."   # from https://infrai.cc/login


# 2) realtime.publish
curl -X POST https://api.infrai.cc/v1/realtime/publish \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"channel": "sample"}'

# 3) realtime.token.issue
curl -X POST https://api.infrai.cc/v1/realtime/token/issue \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"client_id": "sample"}'

# 4) realtime.channel.create
curl -X POST https://api.infrai.cc/v1/realtime/channel/create \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"channel": "sample"}'

# 5) realtime.presence.get
curl -X GET https://api.infrai.cc/v1/realtime/presence/get/CHANNEL \
  -H "Authorization: Bearer $INFRAI_API_KEY"

# 6) realtime.channel.get
curl -X GET https://api.infrai.cc/v1/realtime/channel/get/CHANNEL \
  -H "Authorization: Bearer $INFRAI_API_KEY"

# 7) realtime.channel.delete
curl -X DELETE https://api.infrai.cc/v1/realtime/channel/delete/CHANNEL \
  -H "Authorization: Bearer $INFRAI_API_KEY"

# 8) realtime.channel.list
curl -X GET https://api.infrai.cc/v1/realtime/channel/list \
  -H "Authorization: Bearer $INFRAI_API_KEY"

# 9) realtime.event.types
curl -X GET https://api.infrai.cc/v1/realtime/event/types \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# 1) Auth: every call is a raw HTTPS request carrying only your project key.
#    No SDK to install — just the `requests` library.
import os, requests

BASE = "https://api.infrai.cc"
HEADERS = {
    "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    "Content-Type": "application/json",
}


# 2) realtime.publish
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/realtime/publish",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'channel': 'sample'},
)
resp.raise_for_status()
print(resp.json())

# 3) realtime.token.issue
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/realtime/token/issue",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'client_id': 'sample'},
)
resp.raise_for_status()
print(resp.json())

# 4) realtime.channel.create
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/realtime/channel/create",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'channel': 'sample'},
)
resp.raise_for_status()
print(resp.json())

# 5) realtime.presence.get
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/realtime/presence/get/CHANNEL",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

# 6) realtime.channel.get
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/realtime/channel/get/CHANNEL",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

# 7) realtime.channel.delete
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.delete(
    "https://api.infrai.cc/v1/realtime/channel/delete/CHANNEL",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

# 8) realtime.channel.list
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/realtime/channel/list",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

# 9) realtime.event.types
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/realtime/event/types",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// 1) Auth: every call is a raw HTTPS request carrying only your project key.
//    No SDK to install — just the built-in fetch().
const BASE = "https://api.infrai.cc";
const HEADERS = {
  "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
  "Content-Type": "application/json",
};


// 2) realtime.publish
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/publish",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"channel": "sample"}),
  },
);
console.log(await resp.json());

// 3) realtime.token.issue
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/token/issue",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"client_id": "sample"}),
  },
);
console.log(await resp.json());

// 4) realtime.channel.create
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/create",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"channel": "sample"}),
  },
);
console.log(await resp.json());

// 5) realtime.presence.get
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/presence/get/CHANNEL",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

// 6) realtime.channel.get
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/get/CHANNEL",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

// 7) realtime.channel.delete
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/delete/CHANNEL",
  {
    method: "DELETE",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

// 8) realtime.channel.list
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

// 9) realtime.event.types
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/event/types",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// 1) Auth: every call is a raw HTTPS request carrying only your project key.
//    No SDK to install — just the built-in fetch(), typed.
const BASE = "https://api.infrai.cc";
const HEADERS: Record<string, string> = {
  "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
  "Content-Type": "application/json",
};


// 2) realtime.publish
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/publish",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"channel": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 3) realtime.token.issue
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/token/issue",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"client_id": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 4) realtime.channel.create
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/create",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"channel": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 5) realtime.presence.get
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/presence/get/CHANNEL",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 6) realtime.channel.get
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/get/CHANNEL",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 7) realtime.channel.delete
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/delete/CHANNEL",
  {
    method: "DELETE",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 8) realtime.channel.list
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/channel/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 9) realtime.event.types
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/realtime/event/types",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

5. Developer guides

Move from endpoint details to complete workflows, production patterns and troubleshooting guides verified against the live API.

Realtime developer guides