Events publiceren

Publiceer vanuit je server met je Bird API-key en de key en secret van de Realtime-app. Stuur de app-secret nooit mee in clientcode. Gebruik client events op private of presence channels om geabonneerde clients kortstondige signalen te laten uitwisselen.

Een minimale publish

Een event vereist een naam en minstens één kanaal. De optionele payload kan elk JSON object, array of scalaire waarde bevatten.

import { BirdClient } from "@messagebird/sdk";

const bird = new BirdClient({
  apiKey: process.env.BIRD_API_KEY,
  realtime: {
    key: process.env.BIRD_REALTIME_KEY,
    secret: process.env.BIRD_REALTIME_SECRET,
  },
});

await bird.realtime.publish("rap_01krdgeqcxet5s7t44vh8rt9mg", {
  event: "order-updated",
  channels: ["orders"],
  data: { id: 42, status: "shipped" },
});

import os

from bird import Bird

client = Bird(
    api_key=os.environ["BIRD_API_KEY"],
    realtime_key=os.environ["BIRD_REALTIME_KEY"],
    realtime_secret=os.environ["BIRD_REALTIME_SECRET"],
)

client.realtime.publish(
    "rap_01krdgeqcxet5s7t44vh8rt9mg",
    event="order-updated",
    channels=["orders"],
    data={"id": 42, "status": "shipped"},
)

client, err := bird.NewClient(
	option.WithAPIKey(os.Getenv("BIRD_API_KEY")),
	option.WithRealtimeCredentials(os.Getenv("BIRD_REALTIME_KEY"), os.Getenv("BIRD_REALTIME_SECRET")),
)
if err != nil {
	log.Fatal(err)
}

_, err = client.Realtime.Publish(context.Background(), "rap_01krdgeqcxet5s7t44vh8rt9mg", bird.RealtimePublishParams{
	Event:    "order-updated",
	Channels: []string{"orders"},
	Data:     map[string]any{"id": 42, "status": "shipped"},
})

use MessageBird\Bird;
use MessageBird\RealtimeOptions;
use MessageBird\Wire\Model\RealtimePublish;

$bird = new Bird(
    getenv('BIRD_API_KEY') ?: '',
    realtime: new RealtimeOptions(
        key: getenv('BIRD_REALTIME_KEY') ?: '',
        secret: getenv('BIRD_REALTIME_SECRET') ?: '',
    ),
);

$bird->realtime->publish('rap_01krdgeqcxet5s7t44vh8rt9mg', (new RealtimePublish())
    ->setEvent('order-updated')
    ->setChannels(['orders'])
    ->setData(['id' => 42, 'status' => 'shipped']));

curl -X POST https://us1.platform.bird.com/v1/realtime/apps/rap_01krdgeqcxet5s7t44vh8rt9mg/events \
  -H "Authorization: Bearer $BIRD_API_KEY" \
  -H "X-Realtime-Key: $BIRD_REALTIME_KEY" \
  -H "X-Realtime-Secret: $BIRD_REALTIME_SECRET" \
  -H "Content-Type: application/json" \
  -d '{
    "event": "order-updated",
    "channels": ["orders"],
    "data": { "id": 42, "status": "shipped" }
  }'

Clients die gebonden zijn aan order-updated op orders ontvangen het event. De API weigert door de server gepubliceerde namen die beginnen met de protocolprefixen bird: of bird_internal:. Eventnamen afkomstig van clients moeten beginnen met client-.

Het volledige request en response, inclusief elk veld, staat in de referentie een event publiceren.

Wat een 200 betekent

De publish is voltooid zodra de Realtime-edge het event accepteert. Bezorging is asynchroon en kent geen ontvangstbevestiging per client. Een client die de verbinding verliest tijdens bezorging kan het event missen, en Realtime speelt het niet opnieuw af na herverbinding.

Sla duurzame status op in je database. Gebruik events om wijzigingen aan te kondigen en laat clients de huidige status herladen na herverbinding.

Broadcasten naar meerdere kanalen

Eén aanroep kan hetzelfde event naar maximaal 100 kanalen sturen. Een private-encrypted--kanaal moet het enige kanaal in zijn publish zijn, omdat elk versleuteld kanaal een andere key gebruikt. De API weigert een versleutelde fan-out met E23000. Zie Versleutelde kanalen.

await bird.realtime.publish(appId, {
  event: "price-changed",
  channels: ["ticker-btc", "ticker-eth", "ticker-sol"],
  data: { at: "2026-07-31T09:00:00Z" },
});

client.realtime.publish(
    app_id,
    event="price-changed",
    channels=["ticker-btc", "ticker-eth", "ticker-sol"],
    data={"at": "2026-07-31T09:00:00Z"},
)

_, err := client.Realtime.Publish(context.Background(), appID, bird.RealtimePublishParams{
	Event:    "price-changed",
	Channels: []string{"ticker-btc", "ticker-eth", "ticker-sol"},
	Data:     map[string]any{"at": "2026-07-31T09:00:00Z"},
})

$bird->realtime->publish($appId, (new RealtimePublish())
    ->setEvent('price-changed')
    ->setChannels(['ticker-btc', 'ticker-eth', 'ticker-sol'])
    ->setData(['at' => '2026-07-31T09:00:00Z']));

curl -X POST "https://us1.platform.bird.com/v1/realtime/apps/$APP_ID/events" \
  -H "Authorization: Bearer $BIRD_API_KEY" \
  -H "X-Realtime-Key: $BIRD_REALTIME_KEY" \
  -H "X-Realtime-Secret: $BIRD_REALTIME_SECRET" \
  -H "Content-Type: application/json" \
  -d '{
    "event": "price-changed",
    "channels": ["ticker-btc", "ticker-eth", "ticker-sol"],
    "data": { "at": "2026-07-31T09:00:00Z" }
  }'

Elk doelkanaal telt als een apart bericht voor het verbruik. Dit voorbeeld telt als drie berichten. Een publish naar 10.000 kanalen per gebruiker telt dus als 10.000 berichten.

Niet-gerelateerde events batchen

Een broadcast stuurt één event naar meerdere kanalen. Een batch stuurt tot 10 verschillende events, elk naar één kanaal, in één request.

await bird.realtime.publishBatch(appId, {
  events: [
    { event: "order-updated", channels: ["orders-42"], data: { status: "shipped" } },
    { event: "stock-changed", channels: ["inventory-99"], data: { left: 3 } },
  ],
});

client.realtime.publish_batch(
    app_id,
    events=[
        {"event": "order-updated", "channels": ["orders-42"], "data": {"status": "shipped"}},
        {"event": "stock-changed", "channels": ["inventory-99"], "data": {"left": 3}},
    ],
)

_, err := client.Realtime.PublishBatch(context.Background(), appID, bird.RealtimePublishBatchParams{
	Events: []bird.RealtimeBatchEventParams{
		{Event: "order-updated", Channel: "orders-42", Data: map[string]any{"status": "shipped"}},
		{Event: "stock-changed", Channel: "inventory-99", Data: map[string]any{"left": 3}},
	},
})

$bird->realtime->publishBatch($appId, (new RealtimeBatchPublish())
    ->setEvents([
        (new RealtimeBatchEvent())->setEvent('order-updated')->setChannel('orders-42')->setData(['status' => 'shipped']),
        (new RealtimeBatchEvent())->setEvent('stock-changed')->setChannel('inventory-99')->setData(['left' => 3]),
    ]));

curl -X POST "https://us1.platform.bird.com/v1/realtime/apps/$APP_ID/batch-events" \
  -H "Authorization: Bearer $BIRD_API_KEY" \
  -H "X-Realtime-Key: $BIRD_REALTIME_KEY" \
  -H "X-Realtime-Secret: $BIRD_REALTIME_SECRET" \
  -H "Content-Type: application/json" \
  -d '{
    "events": [
      { "event": "order-updated", "channel": "orders-42", "data": { "status": "shipped" } },
      { "event": "stock-changed", "channel": "inventory-99", "data": { "left": 3 } }
    ]
  }'

Gebruik een batch om niet-gerelateerde updates in één request te combineren. Elk event telt nog steeds apart mee voor het verbruik, en een batch accepteert maximaal 10 events. Zie Een batch publiceren.

De client uitsluiten die de actie heeft uitgevoerd

Als een client zijn actie al lokaal heeft toegepast, geef dan zijn connection-ID mee om te voorkomen dat de resulterende publish dezelfde wijziging opnieuw toepast. De edge slaat alleen die verbinding over.

await bird.realtime.publish(appId, {
  event: "message.created",
  channels: ["presence-room-1"],
  data: { body: "hello" },
  exclude_connection_id: "26896.319537",
});

client.realtime.publish(
    app_id,
    event="message.created",
    channels=["presence-room-1"],
    data={"body": "hello"},
    exclude_connection_id="26896.319537",
)

_, err := client.Realtime.Publish(context.Background(), appID, bird.RealtimePublishParams{
	Event:               "message.created",
	Channels:            []string{"presence-room-1"},
	Data:                map[string]any{"body": "hello"},
	ExcludeConnectionID: "26896.319537",
})

$bird->realtime->publish($appId, (new RealtimePublish())
    ->setEvent('message.created')
    ->setChannels(['presence-room-1'])
    ->setData(['body' => 'hello'])
    ->setExcludeConnectionId('26896.319537'));

curl -X POST "https://us1.platform.bird.com/v1/realtime/apps/$APP_ID/events" \
  -H "Authorization: Bearer $BIRD_API_KEY" \
  -H "X-Realtime-Key: $BIRD_REALTIME_KEY" \
  -H "X-Realtime-Secret: $BIRD_REALTIME_SECRET" \
  -H "Content-Type: application/json" \
  -d '{
    "event": "message.created",
    "channels": ["presence-room-1"],
    "data": { "body": "hello" },
    "exclude_connection_id": "26896.319537"
  }'

Lees het ID uit de huidige verbinding van de client en neem het op in het request dat de wijziging triggert. Andere tabs gebruiken aparte verbindingen en ontvangen het event wel.

Kanaalstatus uitlezen bij het publiceren

Gebruik include om bij het publiceren de status van elk doelkanaal terug te geven en een apart kanaalstatusrequest te vermijden:

const result = await bird.realtime.publish(appId, {
  event: "order-updated",
  channels: ["presence-lobby"],
  data: { id: 42 },
  include: ["member_count", "connection_count"],
});

result = client.realtime.publish(
    app_id,
    event="order-updated",
    channels=["presence-lobby"],
    data={"id": 42},
    include=["member_count", "connection_count"],
)

result, err := client.Realtime.Publish(context.Background(), appID, bird.RealtimePublishParams{
	Event:    "order-updated",
	Channels: []string{"presence-lobby"},
	Data:     map[string]any{"id": 42},
	Include:  []bird.RealtimeChannelInclude{bird.RealtimeIncludeMemberCount, bird.RealtimeIncludeConnectionCount},
})

$result = $bird->realtime->publish($appId, (new RealtimePublish())
    ->setEvent('order-updated')
    ->setChannels(['presence-lobby'])
    ->setData(['id' => 42])
    ->setInclude(['member_count', 'connection_count']));

curl -X POST "https://us1.platform.bird.com/v1/realtime/apps/$APP_ID/events" \
  -H "Authorization: Bearer $BIRD_API_KEY" \
  -H "X-Realtime-Key: $BIRD_REALTIME_KEY" \
  -H "X-Realtime-Secret: $BIRD_REALTIME_SECRET" \
  -H "Content-Type: application/json" \
  -d '{
    "event": "order-updated",
    "channels": ["presence-lobby"],
    "data": { "id": 42 },
    "include": ["member_count", "connection_count"]
  }'

member_count werkt alleen op presence channels. connection_count vereist het tellen van verbindingen op de app. Het opvragen van deze attributen telt als één extra bericht voor het verbruik.

Limieten

Limiet	Waarde
Kanalen per publish	100
Events per batch	10
Event-payload	10 KB geserialiseerd
Kanaalnaam	164 tekens, letters, cijfers en _ - = @ , . ;
Eventnaam	200 tekens

Het overschrijden van een limiet geeft een validatiefout. De API kapt het request niet af.

Veilig opnieuw proberen

Probeer een publish opnieuw met dezelfde Idempotency-Key om dubbele bezorging te voorkomen. De TypeScript- en Go-SDK's genereren een key en hergebruiken die bij automatische retries. Als je applicatie een request opnieuw probeert, geef dan een eigen key mee en hergebruik die. Zie Idempotentie.

Volgende stappen

Kanalen autoriseren is wat een private-- of presence--kanaal nodig heeft voordat een client zich kan abonneren.
Realtime-overzicht legt kanalen, leden en verbindingen uit, en waar het verbruik wordt weergegeven.
Eventontvangers uitsluiten voorkomt dat de handelende client zijn eigen wijziging ontvangt.

Gerelateerde bronnen

Ga verder met de documentatie, gidsen en voorbeelden voor dit onderwerp. De bronnen zijn in het Engels.

Ontdek de mogelijkheidRealtime Volg het leerpadBuild your first integration ImplementatiegidsSend your first realtime event

Probeer de oefening en ontvang een implementatieoverzicht