Turn live events into
real-time insights.

Keep every event in one petabyte-scale database. Schemas flex as your events change; filter, search, aggregate, and join them any way you need.

Start free Start with your agent

Agents turn events into answers

Ask a question. Your agent queries ScopeDB, follows the evidence, and comes back with an answer. Start with your agent.

Checkout failures are up after the payments rollout. Is it the release, or just more traffic?

Agent

First, is this more traffic or a higher failure rate? I'll compare the 15 minutes before and after the 14:15 UTC rollout on Sep 24.

FROM payment_requests
WHERE time >= '2026-09-24 14:00:00+00:00'::timestamp
  AND time < '2026-09-24 14:30:00+00:00'::timestamp
GROUP BY if(time < '2026-09-24 14:15:00+00:00'::timestamp,
  'Before rollout', 'After rollout') AS period
AGGREGATE count() AS requests, sum(if(status >= 500, 1, 0)) AS failures
SELECT period, requests, failures,
  round(10000.0 * failures / requests) / 100.0 AS failure_pct
ORDER BY period DESC

Export task #482 keeps bouncing between our builder, reviewer, and QA agents. Why isn't it finished?

Agent

I'll trace #482. First, its latest recorded state as of 09:40 UTC on Oct 20, then the handoffs since 09:00.

FROM agent.task_snapshots
WHERE workspace = 'release-team' AND environment = 'production'
  AND task_id = 'export-482'
  AND observed_at <= '2026-10-20 09:40:00+00:00'::timestamp
ORDER BY revision DESC
LIMIT 1
SELECT observed_at, title, status, assignee, commit_id

Delivery complaints are rising. Which customers need an update today?

Agent

Is delivery taking a larger share of support calls? I'll use the support system's transcripts and topic labels, counting each call once even when it has several segments.

FROM call_segments
WHERE week IN ('2026-09-14', '2026-09-21')
GROUP BY week
AGGREGATE count_distinct(call_id) AS calls,
  count_distinct(if(topic = 'delivery_delay', call_id, NULL)) AS delivery_calls
SELECT week, calls, delivery_calls,
  round(1000.0 * delivery_calls / calls) / 10.0 AS delivery_pct
ORDER BY week

East's lunch sales look low. Which stores should we call first?

Agent

I'll compare the same stores from 12:00–14:00 UTC on Sep 24 with the same Thursday window a week earlier. Which city accounts for the gap?

FROM pos_events AS sales
JOIN stores ON sales.store_id = stores.id
WHERE stores.region = 'East' AND sales.event = 'purchase_completed'
  AND ((sales.time >= '2026-09-17 12:00:00+00:00'::timestamp
    AND sales.time < '2026-09-17 14:00:00+00:00'::timestamp)
  OR (sales.time >= '2026-09-24 12:00:00+00:00'::timestamp
    AND sales.time < '2026-09-24 14:00:00+00:00'::timestamp))
GROUP BY stores.city AS city, if(sales.time < '2026-09-24 00:00:00+00:00'::timestamp,
  'Sep 17', 'Sep 24') AS period
AGGREGATE count_distinct(sales.receipt_id) AS orders
ORDER BY city, period

Connect your app

Write events and query ScopeDB from your backend with your favorite language.

import { Client } from "scopedb";

const client = new Client(
  process.env.SCOPEDB_ENDPOINT,
  {
    apiKey: process.env.SCOPEDB_API_KEY,
  }
);

const table = client.table("events");
const stream = table.appendStream().build();
await stream.send({
  time: "2026-10-23T09:00:00Z",
  service: "checkout",
  name: "payment_failed",
  message: "Credit card gateway timed out",
  var: { region: "apac", gateway: "credit_card" },
});
await stream.shutdown();

const query = `FROM events WHERE service = 'checkout'
  SELECT time, name, var['gateway']::string AS gateway
  ORDER BY time DESC LIMIT 10`;
const result = await client.query(query);
const events = result.toObjects();

console.log(events);

Read JavaScript SDK docs

func main() {
    ctx := context.Background()
    client, err := scopedb.NewClient(scopedb.Config{
        Endpoint: os.Getenv("SCOPEDB_ENDPOINT"),
        APIKey:   os.Getenv("SCOPEDB_API_KEY"),
    })
    if err != nil { panic(err) }
    defer client.Close()

    opts := scopedb.AppendStreamOptions{}
    stream, err := client.Table("events").AppendStream(opts)
    if err != nil { panic(err) }
    err = stream.Send(ctx, map[string]any{
        "time":    "2026-10-23T09:00:00Z",
        "service": "checkout",
        "name":    "payment_failed",
        "message": "Credit card gateway timed out",
        "var":     map[string]any{"region": "apac", "gateway": "credit_card"},
    })
    if err != nil { panic(err) }
    if _, err := stream.Shutdown(ctx); err != nil { panic(err) }

    query := `FROM events WHERE service = 'checkout'
        SELECT time, name, var['gateway']::string AS gateway
        ORDER BY time DESC LIMIT 10`
    result, err := client.Query(ctx, query)
    if err != nil { panic(err) }
    events, err := result.ToObjects()
    if err != nil { panic(err) }
    fmt.Println(events)
}

Read Go SDK docs

#[tokio::main]
async fn main() {
    let endpoint = std::env::var("SCOPEDB_ENDPOINT").unwrap();
    let api_key = std::env::var("SCOPEDB_API_KEY").unwrap();

    let client = scopedb_client::Client::builder(endpoint)
        .api_key(api_key)
        .build()
        .unwrap();

    let table = client.table("events");
    let stream = table.append_stream().build().unwrap();
    let event = serde_json::json!({
        "time": "2026-10-23T09:00:00Z",
        "service": "checkout",
        "name": "payment_failed",
        "message": "Credit card gateway timed out",
        "var": { "region": "apac", "gateway": "credit_card" },
    });
    stream.send(&event).await.unwrap();
    stream.shutdown().await.unwrap();

    let query = "FROM events WHERE service = 'checkout'
        SELECT time, name, var['gateway']::string AS gateway
        ORDER BY time DESC LIMIT 10";
    let result = client.query(query).await.unwrap();
    let events = result.into_objects().unwrap();

    println!("{events:?}");
}