Recibir eventos en vivo

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

Abre un WebSocket que transmite los eventos de una suscripción conforme llegan.

Parámetros de la ruta

workspace_idstringobligatorio
Tu workspace. Una credencial vinculada a un workspace solo puede nombrar el suyo.
subscription_idstringobligatorio
Una suscripción websocket: sub_ y 26 caracteres.

Encabezados

Authorizationstringobligatorio
Bearer <clave de API>

Descripción

Actualiza a WebSocket con el subprotocolo inovacc.v1. Un navegador, que no puede definir encabezados en un WebSocket, envía su clave publicable como segundo subprotocolo, bearer.<key>, desde un origen que su aplicación liste. Cada trama del servidor es un sobre de evento; confirma con una trama {"ack": ["evt_..."]} (de 1 a 100 ids), respondida con {"acked": n}. Una trama sin confirmar se envía de nuevo tras su concesión. Las tramas del cliente son texto, de máximo 49,152 bytes.

Ver también

Detalles de la fuente

Entrada del catálogo

Id: identity/component-taxonomy/capabilities#events
Repositorio: identity
Ruta: contracts/component-taxonomy/catalog/capabilities.json
Commit: 08ef3cd75d82

Lenguaje

⋮

Credenciales

EncabezadoAuthorizationBearer <clave de API>

Solicitud en cURLEjemplo

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))

Ejemplo

401

Códigos de error: invalid_credentials

403

Códigos de error: forbidden origin_not_allowed

404

Códigos de error: subscription_not_found

409

Códigos de error: wrong_delivery_mode

426

Códigos de error: upgrade_required

429

Códigos de error: rate_limited too_many_streams

503

Códigos de error: service_unavailable