Turn live events into
real-time insights.

Store, search, and analyze all your events in one serverless database.

Trusted by

TrueWatch
Raft.build
Nowledge Mem

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:?}");
}

Read Rust SDK docs

Visualize your events

Use interactive charts to compare trends, investigate events, and share a view with your team.

Track conversion

Follow visits through signup and activation, and see where users drop off.

Signup conversion

Find slow requests

Spot requests above your latency threshold, then trace the wait to logs and dependencies.

Request duration · ms

Trace agent runs

Follow parallel tool calls, a failed search, and its retry before the agent answers.

Agent run

Scale with demand

Retain petabytes of data and ingest millions of events per second.

Data retained: 10 PB+
Peak ingestion: 30 GiB/s
Peak events / second: 10M

Elastic capacity

Workload
Elastic

Compute that scales back down

Keep your event history in shared object storage. Resize ingestion and query groups separately, and release compute after busy periods.

Architecture

Built for production workloads

See how teams run observability platforms, agent-native workspaces, and live service telemetry on ScopeDB.

TrueWatch

Power observability search and analytics

TrueWatch uses ScopeDB as the storage and query engine for logs, traces, and event data across its observability platform.

Read the story

Raft.build

Observe an agent-native workspace

Raft streams execution traces and operational events from its agent workspace into ScopeDB, giving engineers and agents a shared history to investigate issues.

Nowledge Mem