Reference Guide

npm install @apinator/js

npm install @apinator/server

pip install apinator-server

go get github.com/apinator-io/apinator-go

import { RealtimeClient } from '@apinator/js'

const client = new RealtimeClient({
  appKey: 'your-app-key',
  cluster: 'us'
})

client.connect()

const channel = client.subscribe('notifications')
channel.bind('new-alert', (data) => {
  console.log('Received:', data)
})

import { Apinator } from '@apinator/server'

const apinator = new Apinator({
  appId: 'your-app-id',
  key: 'your-key',
  secret: 'your-secret',
  cluster: 'us'
})

await apinator.trigger('notifications', 'new-alert', {
  title: 'New message',
  body: 'You have a new notification'
})

const channel = client.subscribe('live-scores')
channel.bind('score-update', (data) => {
  console.log(data.team, data.score)
})

const client = new RealtimeClient({
  appKey: 'your-app-key',
  cluster: 'us',
  authEndpoint: '/api/realtime/auth'
})

const channel = client.subscribe('private-user-123')

// POST /api/realtime/auth
const auth = apinator.authorizeChannel(
  req.body.socket_id,
  req.body.channel_name
)
res.json(auth)

const auth = apinator.authorizeChannel(
  req.body.socket_id,
  req.body.channel_name,
  {
    user_id: 'user-123',
    user_info: { name: 'Alice' }
  }
)

await apinator.trigger('chat-room', 'new-message', {
  user: 'Alice',
  text: 'Hello, world!'
})

channel.bind('new-message', (data) => {
  console.log(data.user, data.text)
})

channel.trigger('client-typing', {
  user: 'Alice'
})

const channel = client.subscribe('presence-room')

channel.bind('realtime:subscription_succeeded', (members) => {
  console.log('Online:', members.count)
  members.each((member) => {
    console.log(member.id, member.info)
  })
})

channel.bind('realtime:member_added', (member) => {
  console.log('Joined:', member.info.name)
})

channel.bind('realtime:member_removed', (member) => {
  console.log('Left:', member.info.name)
})

POST /apps/{app_id}/events
Content-Type: application/json

{
  "channel": "notifications",
  "event": "new-alert",
  "data": "{\"title\":\"Hello\"}"
}

GET /apps/{app_id}/channels

# Response
{
  "channels": {
    "chat-room": { "subscription_count": 42 },
    "notifications": { "subscription_count": 156 }
  }
}

GET /apps/{app_id}/channels/{channel_name}

# Response
{
  "occupied": true,
  "subscription_count": 42
}

POST /apps/{app_id}/batch
Content-Type: application/json

{
  "batch": [
    { "channel": "room-1", "event": "msg", "data": "..." },
    { "channel": "room-2", "event": "msg", "data": "..." }
  ]
}

npm install @apinator/js

<script src="https://cdn.apinator.io/js/latest/apinator.min.js">script>

import { RealtimeClient } from '@apinator/js'

const client = new RealtimeClient({
  appKey: 'your-app-key',
  cluster: 'us',
  authEndpoint: '/api/realtime/auth'
})

client.connect()

// Public channel
const alerts = client.subscribe('alerts')
alerts.bind('new-alert', (data) => showAlert(data))

// Private channel
const inbox = client.subscribe('private-inbox-123')

// Presence channel
const room = client.subscribe('presence-room')
room.bind('realtime:member_added', (m) => addUser(m))

// Disconnect
client.disconnect()

npm install @apinator/server

import { Apinator } from '@apinator/server'

const apinator = new Apinator({
  appId: 'your-app-id',
  key: 'your-key',
  secret: 'your-secret',
  cluster: 'us'
})

// Publish an event
await apinator.trigger('chat', 'message', { text: 'Hello' })

// Authorize a private channel
const auth = apinator.authorizeChannel(socketId, channelName)

// Query channels
const channels = await apinator.getChannels()

// Verify a webhook
const valid = apinator.verifyWebhook(signature, timestamp, body)

pip install apinator-server

from apinator import Apinator

apinator = Apinator(
    app_id='your-app-id',
    key='your-key',
    secret='your-secret',
    cluster='us'
)

# Publish an event
apinator.trigger('chat', 'message', {'text': 'Hello'})

# Authorize a private channel
auth = apinator.authorize_channel(socket_id, channel_name)

# Verify a webhook
valid = apinator.verify_webhook(signature, timestamp, body)

go get github.com/apinator-io/apinator-go

import "github.com/apinator-io/apinator-go"

client, err := apinator.New(
    apinator.WithAppID("your-app-id"),
    apinator.WithKey("your-key"),
    apinator.WithSecret("your-secret"),
    apinator.WithCluster("us"),
)

// Publish an event
err = client.Trigger(ctx, "chat", "message", map[string]string{
    "text": "Hello",
})

// Authorize a channel
auth, err := client.AuthorizeChannel(socketID, channelName)

composer require apinator/apinator-php

use Apinator\\Apinator;

$apinator = new Apinator([
    'app_id' => 'your-app-id',
    'key' => 'your-key',
    'secret' => 'your-secret',
    'cluster' => 'us'
]);

// Publish an event
$apinator->trigger('chat', 'message', ['text' => 'Hello']);

// Authorize a channel
$auth = $apinator->authorizeChannel($socketId, $channelName);

.package(url: "https://github.com/apinator-io/apinator-swift", from: "1.0.0")

import ApinatorSDK

let client = RealtimeClient(
    appKey: "your-app-key",
    cluster: "us",
    authEndpoint: "https://your-server.com/api/realtime/auth"
)

client.connect()

let channel = client.subscribe("notifications")
channel.bind("new-alert") { data in
    print("Received: \(data)")
}

implementation("com.apinator:sdk:1.0.0")

import com.apinator.sdk.RealtimeClient

val client = RealtimeClient(
    appKey = "your-app-key",
    cluster = "us",
    authEndpoint = "https://your-server.com/api/realtime/auth"
)

client.connect()

val channel = client.subscribe("notifications")
channel.bind("new-alert") { data ->
    println("Received: $data")
}

body_md5 = len(body) == 0 ? "" : hex(md5(body))
sig_string = "{timestamp}\n{METHOD}\n{path}\n{body_md5}"
signature = hex(hmac_sha256(secret, sig_string))

{
  "auth": "app-key:hmac-signature",
  "channel_data": "{\"user_id\":\"123\",\"user_info\":{\"name\":\"Alice\"}}"
}

{
  "event": "channel_occupied",
  "channel": "chat-room",
  "timestamp": 1700000000
}

const valid = apinator.verifyWebhook(
  req.headers['x-webhook-signature'],
  req.headers['x-webhook-timestamp'],
  req.body
)

if (!valid) {
  return res.status(401).send('Invalid signature')
}