Athena Data Platform

One gateway for every database workflow.

Query, pipeline, manage, and operate your data stack with Athena. Ship faster with a unified API, multi-backend routing, SDKs, and cluster-grade backup and restore workflows.

Built for data teams shipping production systems across analytics, apps, and operations.

Analytics stack logoOperations stack logoCloud stack logoEngineering stack logo

Unified Gateway

Use one consistent contract for fetch, insert, update, delete, SQL, and RPC across Postgres, Supabase, and Scylla-backed workloads. 

const response = await fetch("https://athena-db.com/gateway/fetch", {
  method: "POST",
  headers: {
    "content-type": "application/json",
    "x-athena-client": "analytics",
    "x-athena-key": process.env.ATHENA_API_KEY!,
  },
  body: JSON.stringify({
    table: "events",
    columns: ["id", "type", "created_at"],
    conditions: [{ column: "type", operator: "eq", value: "checkout.completed" }],
    order_by: { column: "created_at", direction: "desc" },
    limit: 50
  }),
});

const payload = await response.json();
console.log(payload.status, payload.data);

Operational Control Plane

Manage clients, schema, backups, restore jobs, metrics, and routing from a single platform built for production operations. 

# Trigger backup
curl -X POST "https://athena-db.com/admin/backups" \
  -H "x-athena-client: athena_logging" \
  -H "x-athena-admin-key: $ATHENA_ADMIN_KEY" \
  -H "content-type: application/json" \
  -d '{"client_name":"athena_logging","bucket":"athena-prod-backups"}'

# Monitor restore/backup workers
curl "https://athena-db.com/admin/backups/jobs" \
  -H "x-athena-client: athena_logging" \
  -H "x-athena-admin-key: $ATHENA_ADMIN_KEY"
Core capabilities

Build with one control plane run every data workflow

Athena combines data access, schema operations, automation, and runtime reliability so teams can ship faster without stitching together many tools.

Gateway CRUD + SQL

Use /gateway/fetch, /insert, /update, /delete, /query, and /gateway/sql through one stable contract.

Multi-Backend Routing

Route with X-Athena-Client to PostgreSQL pools, Supabase projects, and Scylla-backed workloads.

Pipeline Engine

Run source-transform-sink flows with /pipelines and /pipelines/simulate for reliable ETL and sync.

Schema + DDL APIs

Provision, inspect, and evolve schema with management endpoints for tables, columns, indexes, and extensions.

Backup + Restore

Create jobs, schedule recurring backups, and restore from S3-compatible storage with built-in job tracking.

Observability Built In

Track health, metrics, admission events, vacuum stats, optimization runs, and operation-level drilldowns.

End-to-end platform

From query to recovery without switching systems.

Athena centralizes data access, automation, and reliability workflows for teams operating at scale.

API Layer

Consistent Request Contract

Every operation follows one envelope with predictable status, message, and data semantics.

Driver Layer

Backend-Aware Execution

Athena routes the same intent to SQLx, Supabase REST/RPC, or Scylla-native execution paths.

Operations Layer

Production Tooling

Cluster health, backups, restore, provisioning, and metrics are first-class API surfaces.

Developer Layer

SDK + MCP Access

Integrate from Rust, TypeScript helpers, and the Athena MCP server without re-implementing low-level calls. 

// Run a named pipeline
const response = await fetch("https://athena-db.com/pipelines", {
  method: "POST",
  headers: {
    "content-type": "application/json",
    "x-athena-client": "athena_logging",
    "x-athena-key": process.env.ATHENA_API_KEY!,
  },
  body: JSON.stringify({
    pipeline: "daily_events_rollup",
    source: {
      table_name: "events",
      conditions: [{ eq_column: "kind", eq_value: "checkout.completed" }],
      limit: 10000
    },
    transform: {
      group_by: "organization_id",
      aggregation_column: "amount_cents",
      aggregation_strategy: "sum"
    },
    sink: { table_name: "daily_checkout_totals" }
  }),
});

const result = await response.json();
console.log(result.status, result.message);
Proven outcomes

Reliability you can operate, velocity you can ship with.

Athena helps teams reduce operational drag while improving database performance and recovery confidence across environments.

With unified APIs, observability, and automation, engineering teams spend less time on plumbing and more time delivering product features.

Gateway uptime
p95 latency improvement
Restore success rate
Operator overhead reduction
Trusted by engineering and platform teams

Built for operators, loved by developers

David Gutierrez

David Gutierrez

Principal Data Engineer

"We replaced three internal services with Athena and cut our integration time from weeks to days."

Pierluigi Camomillo

Pierluigi Camomillo

Platform Lead

"The gateway contract is stable and predictable. Teams can move fast without constantly rewriting data access code."

Ella Svensson

Ella Svensson

Staff Backend Engineer

"Backups, restore jobs, and client routing used to be fragmented. Athena brought all of it into one reliable workflow."

Alexa Rios

Alexa Rios

Head of Infrastructure

"Observability and admin APIs are first-class. Our on-call burden dropped because we can debug and recover faster."

Marco Tulio

Marco Tulio

Senior Solutions Architect

"The MCP integration made internal automation straightforward. We now orchestrate data operations directly from agent workflows."

Samantha Lee

Samantha Lee

Product Engineering Manager

"Athena let product teams own data features end-to-end with guardrails, not bottlenecks."

Pricing

Transparent plans, built for real operations.

Start free, scale with your workloads, and move to enterprise controls when your platform needs it.

Developer

$0/month

Build and validate Athena workflows locally.

  • Core gateway endpoints
  • Single client configuration
  • Schema introspection + SQL execution

Team Most Popular

$299/month/month

Production-ready operations for growing teams.

  • Multi-client routing
  • Backup + restore job workflows
  • Pipelines, metrics, and admin APIs
  • Role-based API key rights
  • WebSocket + MCP integration

Enterprise

Custom/month

For high-scale, regulated, or managed environments.

  • Cluster-level governance controls
  • Query optimization + vacuum health workflows
  • Dedicated support and migration guidance
  • Custom provisioning automation
  • Advanced security and compliance setup
FAQ

Frequently Asked Questions

Need more details before adopting Athena?

Contact us
What does Athena replace in a typical stack?
Athena can replace or simplify custom API gateways, ad-hoc ETL scripts, one-off admin tools, and fragmented backup workflows by offering one unified data and operations surface.
How do clients choose the target database?
Requests are routed with the X-Athena-Client header. Athena resolves the logical client to configured PostgreSQL pools, Supabase projects, or other supported backends.
Can we run backups and restore through API calls?
Yes. Athena exposes backup and restore APIs, job tracking, schedule management, and S3-compatible storage support for AWS S3, MinIO, and similar providers.
Do you support both synchronous and deferred execution?
Yes. You can execute requests inline or defer selected gateway operations to the built-in deferred queue and check status with dedicated deferred request endpoints.
Is there SDK support for developers?
Athena includes a Rust AthenaClient SDK and TypeScript helper layer used by the web app, plus a full OpenAPI contract for generating additional client implementations.
How does Athena integrate with agent workflows?
Athena exposes MCP-compatible operations that map to gateway, management, schema, backup, and admin capabilities so LLM agents can safely execute governed data tasks.
Can we apply schema changes with permissions?
Yes. Management endpoints for tables, columns, indexes, extensions, and functions are protected by API key rights so teams can enforce role-appropriate access.
Where can we review full API coverage?
Athena serves OpenAPI specs at /openapi.yaml and /openapi-wss.yaml. The docs include endpoint coverage for gateway, admin, management, storage, routing, and observability.

Build with Athena

Start with the gateway, scale with pipelines and operations APIs, and standardize your data platform with one contract.

Read docs Explore OpenAPI