Receber eventos ao vivo

GEThttps://events.inovacc.dev/v1/workspaces/{workspace_id}/subscriptions/{subscription_id}/stream

Abre um WebSocket que transmite os eventos de uma assinatura à medida que chegam.

Parâmetros do caminho

workspace_idstringobrigatório
Seu workspace. Uma credencial vinculada a um workspace só pode indicar o próprio.
subscription_idstringobrigatório
Uma assinatura websocket: sub_ e 26 caracteres.

Cabeçalhos

Authorizationstringobrigatório
Bearer <chave de API>

Descrição

Faça o upgrade para WebSocket com o subprotocolo inovacc.v1. Um navegador, que não consegue definir cabeçalhos em um WebSocket, envia sua chave publicável como segundo subprotocolo, bearer.<key>, a partir de uma origem que a aplicação dele lista. Cada frame do servidor é um envelope de evento; confirme com um frame {"ack": ["evt_..."]} (1 a 100 ids), respondido com {"acked": n}. Um frame sem confirmação é enviado de novo após a sua concessão. Os frames do cliente são texto, com no máximo 49.152 bytes.

Veja também

Detalhes da fonte

Entrada do catálogo

Id: identity/component-taxonomy/capabilities#events
Repositório: identity
Caminho: contracts/component-taxonomy/catalog/capabilities.json
Commit: 08ef3cd75d82

Linguagem

⋮

Credenciais

CabeçalhoAuthorizationBearer <chave de API>

Requisição em cURLExemplo

cURL

1
2curl "https://events.inovacc.dev/v1/workspaces/{workspace_id}/subscriptions/{subscription_id}/stream" \
  -H "Authorization: Bearer $INOVACC_API_KEY"

TypeScript

1
2
3
4
5
6
7
8
9
10const url = "https://events.inovacc.dev/v1/workspaces/{workspace_id}/subscriptions/{subscription_id}/stream";

const response = await fetch(url, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.INOVACC_API_KEY}`,
  },
});

console.log(response.status, await response.text());

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14import os
import urllib.request

request = urllib.request.Request(
    "https://events.inovacc.dev/v1/workspaces/{workspace_id}/subscriptions/{subscription_id}/stream",
    method="GET",
    headers={
        "User-Agent": "inovacc-python-sample",
        "Authorization": "Bearer " + os.environ["INOVACC_API_KEY"],
    },
)

with urllib.request.urlopen(request) as response:
    print(response.status, response.read().decode())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30package main

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

const url = "https://events.inovacc.dev/v1/workspaces/{workspace_id}/subscriptions/{subscription_id}/stream"

func main() {
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INOVACC_API_KEY"))

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(res.Status, string(out))
}

Rust

1
2
3
4
5
6
7
8
9
10
11// Cargo.toml: reqwest = { version = "0.12", features = ["blocking", "json"] }

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("INOVACC_API_KEY")?;
    let response = reqwest::blocking::Client::new()
        .get("https://events.inovacc.dev/v1/workspaces/{workspace_id}/subscriptions/{subscription_id}/stream")
        .bearer_auth(api_key)
        .send()?;
    println!("{} {}", response.status(), response.text()?);
    Ok(())
}

JavaScript

1
2
3
4
5
6
7
8
9
10const url = "https://events.inovacc.dev/v1/workspaces/{workspace_id}/subscriptions/{subscription_id}/stream";

const response = await fetch(url, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.INOVACC_API_KEY}`,
  },
});

console.log(response.status, await response.text());

PHP

1
2
3
4
5
6
7
8
9
10
11
12
13<?php

$curl = curl_init('https://events.inovacc.dev/v1/workspaces/{workspace_id}/subscriptions/{subscription_id}/stream');
curl_setopt_array($curl, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('INOVACC_API_KEY'),
    ],
]);

$response = curl_exec($curl);
echo curl_getinfo($curl, CURLINFO_HTTP_CODE), ' ', $response, "\n";
curl_close($curl);

Ruby

1
2
3
4
5
6
7
8
9
10
11
12
13require "net/http"
require "uri"

uri = URI('https://events.inovacc.dev/v1/workspaces/{workspace_id}/subscriptions/{subscription_id}/stream')

request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer #{ENV.fetch('INOVACC_API_KEY')}"

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

puts "#{response.code} #{response.body}"

Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        String apiKey = System.getenv("INOVACC_API_KEY");

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://events.inovacc.dev/v1/workspaces/{workspace_id}/subscriptions/{subscription_id}/stream"))
                .header("Authorization", "Bearer " + apiKey)
                .GET()
                .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
                .send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode() + " " + response.body());
    }
}

1
2
3
4
5
6
7
8
9var url = "https://events.inovacc.dev/v1/workspaces/{workspace_id}/subscriptions/{subscription_id}/stream";
var apiKey = Environment.GetEnvironmentVariable("INOVACC_API_KEY");

using var client = new HttpClient();
using var request = new HttpRequestMessage(HttpMethod.Get, url);
request.Headers.Add("Authorization", $"Bearer {apiKey}");

using var response = await client.SendAsync(request);
Console.WriteLine($"{(int)response.StatusCode} {await response.Content.ReadAsStringAsync()}");

Kotlin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse

fun main() {
    val apiKey = System.getenv("INOVACC_API_KEY")

    val request = HttpRequest.newBuilder()
        .uri(URI.create("https://events.inovacc.dev/v1/workspaces/{workspace_id}/subscriptions/{subscription_id}/stream"))
        .header("Authorization", "Bearer " + apiKey)
        .GET()
        .build()

    val response = HttpClient.newHttpClient()
        .send(request, HttpResponse.BodyHandlers.ofString())
    println("${response.statusCode()} ${response.body()}")
}

Swift

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif

let apiKey = ProcessInfo.processInfo.environment["INOVACC_API_KEY"] ?? ""

let url = URL(string: "https://events.inovacc.dev/v1/workspaces/{workspace_id}/subscriptions/{subscription_id}/stream")!
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
let status = (response as? HTTPURLResponse)?.statusCode ?? 0
print(status, String(decoding: data, as: UTF8.self))

Exemplo

401

Códigos de erro: invalid_credentials

403

Códigos de erro: forbidden origin_not_allowed

404

Códigos de erro: subscription_not_found

409

Códigos de erro: wrong_delivery_mode

426

Códigos de erro: upgrade_required

429

Códigos de erro: rate_limited too_many_streams

503

Códigos de erro: service_unavailable