Je sessieregels bepalen wie zich mag abonneren.

Er is geen rechtenmodel om te configureren in Bird. Een private- of presence-subscription wordt goedgekeurd door een endpoint dat je schrijft, met de sessie die je al hebt, en ondertekend met een secret dat alleen jouw servers kennen. Bird verifieert de handtekening; jij bepaalt het beleid.

Aan de slag Neem contact op met sales

auth.ts

200 · signed

// Your endpoint. The only place the app secret lives.
app.post("/bird/auth", async (req, res) => {
  const { connection_id, channel_name } = req.body;
  const user = await session(req);

  if (!mayJoin(user, channel_name)) return res.sendStatus(403);

  // Signs <connection_id>:<channel_name>[:<member_data>] with the app
  // secret, and adds shared_secret on an encrypted channel.
  res.json(
    await bird.realtime.authorizeChannel({
      connectionId: connection_id,
      channelName: channel_name,
      memberData: JSON.stringify({
        member_id: user.id,
        member_info: { name: user.name },
      }),
    }),
  );
});

auth.ts

200 · signed

// Your endpoint. The only place the app secret lives.
app.post("/bird/auth", async (req, res) => {
  const { connection_id, channel_name } = req.body;
  const user = await session(req);

  if (!mayJoin(user, channel_name)) return res.sendStatus(403);

  // Signs <connection_id>:<channel_name>[:<member_data>] with the app
  // secret, and adds shared_secret on an encrypted channel.
  res.json(
    await bird.realtime.authorizeChannel({
      connectionId: connection_id,
      channelName: channel_name,
      memberData: JSON.stringify({
        member_id: user.id,
        member_info: { name: user.name },
      }),
    }),
  );
});

Eén key is publiek. De andere niet.

Alles volgt uit die scheiding.

Elke app op de Bird Realtime API heeft een key en een secret. De key is bedoeld om mee te leveren in clientcode; het secret authenticeert de calls van je server en ondertekent subscriptions, en het wordt één keer getoond, bij aanmaak. Iedereen die het bezit kan naar je app publiceren en een presence-identiteit vervalsen, dus behandel het als een databasewachtwoord. Rotatie is additief in plaats van verstorend: maak een tweede key aan, deploy die, en trek dan de oude in.

Vier controles, vier vragen

Wie mag subscriben, wie mag een verbinding openhouden, wie kan een payload lezen, en wie is nog steeds toegelaten.

01
Ondertekende subscriptions.
De client post zijn connection id en de channelnaam naar jouw endpoint. Je controleert de aanroeper, weiger met een 403 als die niet mag deelnemen, of retourneer een HMAC-SHA256-handtekening over connection id en channelnaam, voorafgegaan door de app key. Omdat het connection id in de handtekening zit, dekt een goedkeuring één verbinding en kan die niet worden hergebruikt op een andere. Een presence channel ondertekent ook de member-identiteit, en dat moet exact de string zijn die je retourneert: hetzelfde object opnieuw serialiseren kan keys herschikken en de handtekening ongeldig maken.
02
Geautoriseerde verbindingen.
De app key is publiek, dus iedereen die je pagina kan laden kan er een socket mee openen. Schakel geautoriseerde verbindingen in en elke nieuwe verbinding heeft 30 seconden om te bewijzen dat iets met het secret ervoor heeft ingestaan, via een private subscription of een sign-in. Alles wat dat niet doet wordt gesloten met code 4009, en ongeautoriseerde verbindingen tellen nooit mee voor je quotum. Subscriben op een public channel bewijst niets en autoriseert geen verbinding.
03
End-to-end-encryptie.
Een private-encrypted- channel wordt door je server verzegeld voordat het verzoek je proces verlaat, met een 32-byte master key die nooit voorkomt in een Realtime API-verzoek. Elk channel leidt zijn eigen key af, dus het autoriseren van een client voor één encrypted channel geeft geen toegang tot een ander. Bird kan een verloren key niet herstellen, en rotatie beschermt toekomstige payloads, niet eerdere.
04
Toegang nu intrekken.
Een uitgelogde gebruiker, een gewijzigd wachtwoord, een verbannen account: ontkoppel het lid en elke verbinding die die identiteit aanhoudt wordt gesloten, op elk apparaat. De clients behandelen die sluiting als definitief in plaats van opnieuw te proberen, en jouw eigen endpoints stoppen met ondertekenen voor hen, dus ze kunnen niet terugkomen.

Encrypted channels

Payloads die Bird niet kan lezen, op infrastructuur die Bird draait.

Lees de encryptiegids

De server-SDK detecteert het channelprefix, leidt de key van dat channel af van je master key, en verzegelt de payload lokaal. De edge stuurt ciphertext door en jouw autorisatie-endpoint geeft de afgeleide key alleen aan clients die het goedkeurt. Twee beperkingen om rekening mee te houden: channel- en eventnamen reizen in plaintext, dus kies namen die niet lekken wat je beschermt, en encryptie kan niet worden gecombineerd met presence of met client events. Caching kan wel: een private-encrypted-cache- channel slaat zijn gecachte event verzegeld op.

encrypted.ts

sealed locally

const bird = new BirdClient({
  apiKey: process.env.BIRD_API_KEY!,
  realtime: {
    key: process.env.BIRD_REALTIME_KEY,
    secret: process.env.BIRD_REALTIME_SECRET,
    // 32 random bytes, yours alone. Never sent to Bird.
    encryptionMasterKey: process.env.BIRD_REALTIME_MASTER_KEY,
  },
});

// Sealed in your process. The edge forwards ciphertext.
await bird.realtime.publish(APP_ID, {
  event: "order.updated",
  channels: ["private-encrypted-orders"],
  data: { order_id: "ord_123", status: "shipped" },
});

Wat autorisatie niet doet.

Geautoriseerde verbindingen vereisen bepaalt wie een socket open mag houden. Het verandert niet wie een channel kan lezen: een public channel blijft leesbaar door elke geautoriseerde verbinding, dus events die bij één klant horen, horen op een private channel waarvan jouw endpoint de naam controleert. En omdat jouw endpoints de autoriteit zijn, deelt een permissief endpoint toegang net zo vrij uit als een gelekt secret zou doen. Dezelfde eerlijkheid geldt voor client events, die de edge niet valideert: gebruik ze voor signalen, en routeer alles wat gezaghebbend is via je server.

Waar de data staat.

Een app kiest zijn regio wanneer je hem aanmaakt en behoudt die voor altijd, dus je kiest de regio die het dichtst bij je gebruikers ligt, en de regio van een app kan afwijken van de thuisregio van je werkruimte. Apps zijn ook de isolatiegrens: twee apps zien nooit elkaars channels, en daarom is één app per omgeving de juiste manier om stagingverkeer uit productie te houden.

Ga dieper in de docs.

Channels autoriseren beschrijft het request- en responsecontract en de exacte string om te ondertekenen. Geautoriseerde verbindingen vereisen behandelt het 30-secondenvenster en code 4009, encrypted channels behandelt het genereren en roteren van keys, en verbindingen van leden beëindigen is de sign-in- en disconnect-flow.

De rest van Realtime

Eén app, één key pair. Ontdek de andere mogelijkheden.

ChannelsPublic, private, presence, encrypted en cached, allemaal bepaald door de naam.PresenceWie in de ruimte is, wie net weg is, en hoe je één persoon direct bereikt.WebhooksJe server hoort wanneer een channel vol raakt, leegloopt of zijn cache mist.PrijzenVerbindingen en berichten per plan, vanaf de gratis tier.Aan de slagVan aanmelding tot je eerste gepubliceerde event.Realtime API-overzichtHet hele product: channels, presence, beveiliging, webhooks en de clients.

Schaal op zonder
controle te verliezen.

Organiseer teams in werkruimtes, beheer API-toegang en traceer wijzigingen via auditlogs.

HarborOrganisatie

WerkruimtesProductieSandbox

Verzendagent

API-sleutel · Team Klantoperaties

Actief

MachtigingenToegang

EmailLezen en schrijven

SMSLezen en schrijven

ALAlex Lee BeheerderMachtigingen bijgewerkt

Auditlog

Productie

Werkruimte: Productie
Resource: Verzendagent
WhatsApp: LeestoegangLezen en schrijven

Geslaagd

Ontdek Enterprise

Begin met Realtime.
Bouw over kanalen heen met Bird.