Peaka

Peaka is a zero-ETL data platform that connects databases and SaaS APIs and exposes them as queryable catalogs. Agents manage projects and connections, browse catalogs and schemas, run SQL across sources, build internal tables and ask Peaka's AI agent questions about the data.

Verified 109 actions API key available

Peaka website Platform Documentation Capability data verified 2026-08-27

A second team asks for standing access to the customer data a Peaka project already connects

List Catalogs and Get Catalog Relations return what the catalog exposes and how its tables join

List Catalog Columns and Search Data enumerate the exact columns the request would reach

Check Table Is Cached reports which tables are served from Peaka storage and which call the source on every query

Update Metadata confirms the AI usage setting on any source that should stay out of natural language answers

Agent posts the column inventory and the expected load on each source to the data owner

The data owner decides whether Share Catalog runs, because sharing grants standing access to a live source

What This Integration Enables

Peaka's answer to the data pipeline is to not build one. It connects to databases and SaaS APIs, exposes each as a catalog, and lets you query across all of them in SQL as though they were one warehouse. There is no extract sitting in the middle, which is the whole argument: the rows you read are the rows the source has right now, and a schema change in the source is visible immediately rather than after a pipeline run fails. For a team that wants to answer questions across five systems without hiring someone to maintain the plumbing between them, that trade is a good one.

It also moves where the risk lives, and workflows should be built with that in mind. Because there is no copy, caching is the only lever on both query latency and source quota, and a cache that has quietly stopped refreshing serves stale rows without raising anything. Because the catalog is live, sharing one is closer to granting a credential than to sending a file. And because Peaka's own AI agent writes SQL against your catalogs and runs it by default, the quality of the metadata around your tables matters more than the model does. FlowRunner agents work all three of those surfaces: they query and grade freshness, they build the relations and worked examples that make natural language answers trustworthy, and they stop before the operations that widen who can reach a live system.

Without FlowRunner

Access granted by copy Sharing data means producing an extract, which is stale the moment it lands and impossible to recall

Nobody knows what a share reaches A request is approved on a table name, without the column list or the source behind it

Source load discovered in production A new consumer hits a rate limited API and the first sign is a failing dashboard

With FlowRunner

Access granted by catalog A catalog is a live view, so consumers read current rows and revocation is a real operation

Shares reviewed against a column list The agent enumerates every column and relation a share would expose before anyone approves it

Load is a number before it is an incident Cache state and refresh mode are read up front, so the cost of a new consumer is known in advance

Use Case Scenarios

A cross-source question answered without a pipeline

Someone asks in the analytics channel why churn rose in the enterprise segment last month. The agent calls Chat With Agent with No Execute turned on, so Peaka's agent writes the SQL and hands it back rather than running it. The statement joins the product database, the billing rows, and the support tickets, three sources that live in three systems and have never been co-located. A reviewer reads the SQL, the agent runs it through Execute Query with bind parameters rather than values built into the text, and the answer posts to Slack with the query attached. The same question next month costs one call, because Create Golden SQL registered the query that answered it correctly.
The grounding loop, run as a workflow instead of a project

Natural language answers are only as good as the metadata behind them, and most of that metadata does not exist by default. Sources without foreign keys, which is most SaaS APIs, have no relations at all until somebody adds them. So the agent runs the loop. List Catalog Tables and List Catalog Columns inventory what is connected. Generate Table Semantics drafts column descriptions across a large schema faster than anyone will write them by hand. Add Metadata Relation records the joins the agent would otherwise guess at. Manage Categorical Values on a status or category column is what lets a phrase in a question map onto a real value in the data. Generate Sample Questions produces candidates for review, and the ones a person confirms become Golden SQL. This is slow, unglamorous work that nobody schedules and an agent will do every week.
Keeping the cost and the freshness honest

Zero ETL means every uncached query reaches a source that may be metered, rate limited, or simply slow. The agent audits that on a cadence. List Cache Statuses and List Materialized Query Statuses catch anything that has stopped refreshing before a dashboard goes quietly stale. Check Table Is Cached tells it which tables are served from Peaka storage and which are calling the source on every read. Where a table is hot and the source is metered, Create Cache puts it in Peaka storage with an incremental schedule for routine top ups. Refresh Cache is then used deliberately, because a full refresh re-reads the entire table from the source and is the expensive one. Results that other tools need are moved out with Export Data into Metabase, while the sources themselves stay where they are, whether that is Snowflake, Google BigQuery, or PostgreSQL.

Human-in-Loop Highlight

Share Catalog is one line in an API and a standing grant in practice. Because a Peaka catalog is a live view rather than an extract, sharing it with another project or team hands over query access to the source system itself, and that access covers rows that do not exist yet. The approver is not deciding about the data they can see today. They are deciding about every row that source will hold until somebody revokes the share, and revocation is an action nobody schedules. So the agent does the work and stops. It calls List Catalog Columns and Get Catalog Relations to enumerate exactly what would be reachable, checks Update Metadata to confirm whether AI usage is enabled on the catalog, and asks: "Growth is requesting the customers catalog. It exposes 41 columns across 6 tables from the production database, including billing_email and support_notes, and joins to the invoices table. It is uncached, so every query they run hits production. AI usage is currently on, so their agent could reach these columns in natural language answers. Share as requested, share a semantic catalog with a narrower column set, or refuse?" The data owner answers. The related operations are just as final: Delete Catalog stops every query that referenced its tables, and Delete API Key revokes a credential immediately, breaking whatever was using it. Agents at machine speed plus human-in-the-loop at the boundary is what makes a self-serve data layer something a security review can survive.

Agent processes routinely

Detects production

Clear match Continues automatically

Ambiguous Routes to human via email

Human decides

Agent resumes with decision

Agent Capabilities

109 actions

Organizations and Workspaces

List Organizations Returns the Peaka organizations the API key can reach. An organization is the top of the hierarchy, above workspaces and projects, and its id is what the workspace operations need.
Get Organization Returns a single organization by id, with its name and settings.
List Workspaces Returns the workspaces inside an organization. A workspace groups projects, which is where connections, catalogs and queries actually live.
Create Workspace Creates a workspace inside an organization and returns it with its new id.
Get Workspace Returns a single workspace by id, with its name and description.
Update Workspace Updates a workspace's name or description. This is a PUT, so send the full set of fields you want the workspace to end up with rather than only the changed ones.
Delete Workspace Permanently deletes a workspace and the projects inside it. There is no undo on this API.

Projects and API Keys

List Projects Returns the projects inside a workspace. A project owns the connections, catalogs, queries and caches, so its id is what almost every other operation on this API needs.
Create Project Creates a project inside a workspace and returns it with its new id.
Get Project Returns a single project by id, with its name, description and workspace.
Update Project Updates a project's name or description. This is a PUT, so send the full set of fields you want the project to end up with.
Delete Project Permanently deletes a project along with its connections, catalogs, queries and caches. There is no undo on this API.
List API Keys Returns the API keys issued for a project, with their names and expiry. The key values themselves are not returned, because Peaka shows them only once at creation.
Create API Key Issues a project scoped API key and returns its value. The value appears only in this response and cannot be retrieved later.
Delete API Key Revokes an API key immediately. Anything using that key stops working at once, so check List API Keys for what a key is named before revoking it.

Connections

List Connection Types Returns every data source Peaka can connect to, with the configuration each one requires. Call it before Create Connection to learn the type string and the shape of the credential object, both of which differ per source.
Get Connection Type Returns the configuration a single connection type requires: its authentication method and the exact credential fields.
List Connections Returns the configured connections in a project, each with its type and status. A connection is what a catalog is built on, so this is the step between choosing a project and querying external data.
Create Connection Creates a connection to an external data source in a project. The Credential object's shape is defined by the connection type rather than by this API, so read it from Get Connection Type first.
Get Connection Returns a single connection by id, with its type and current status.
Get Connection Detail Returns the full configuration of a connection, including the credential fields it was created with (with secrets masked) and any source specific settings.
Update Connection Updates a connection's name or credentials. Use it to rotate a source's API key without rebuilding the catalogs and queries that depend on the connection.
Delete Connection Permanently deletes a connection. Catalogs built on it stop resolving, and queries against those catalogs start failing, so check what depends on it first.
Complete OAuth Connection Completes an OAuth connection by handing Peaka the callback parameters the provider returned. Only OAuth based sources need this; key based sources are finished by Create Connection alone.

Catalogs and Browsing

List Catalogs Returns the catalogs in a project. A catalog is a connection surfaced as queryable schemas and tables, which is what makes data from an external source addressable in SQL.
Create Catalog Creates a catalog over an existing connection, making that source's data queryable. The catalog name becomes the first part of every qualified table name, so choose something you will want to type in SQL.
Get Catalog Returns a single catalog by id, with the connection it reads from and its configuration.
Delete Catalog Permanently deletes a catalog. Queries referencing its tables stop resolving; the underlying connection and the source data are untouched.
Share Catalog Shares a catalog so that other projects or users can query it, which is how a single connection serves several teams without being configured repeatedly.
List Schemas Returns the schemas inside a catalog. A qualified table name in Peaka SQL is catalog.schema.table, so this is the middle step of resolving one.
List Catalog Tables Returns the tables inside a schema of a catalog. Together with List Catalogs and List Schemas this walks the tree down to a queryable table name.
List Catalog Columns Returns the columns of a table in a catalog, with their data types. This is the schema a query written against that table must match.
Get Table Statistics Returns row counts and column statistics for a table in a catalog. Use it to decide whether a table is worth caching, or to sanity check that a connection is returning the data you expect.
Check Table Is Cached Reports whether a table is currently cached in Peaka. A cached table is served from Peaka's own storage rather than by calling the source on every query, which is the difference between a fast dashboard and a rate limited one.
Search Data Searches catalog, schema, table and column names across a project by a case insensitive substring. Use it to find where a field lives when you know its name but not which source it came from, which is the common problem in a workspace joining many connections.

Tables and Columns

List Tables Returns the tables Peaka stores itself, in either of its two families. Peaka Tables are ordinary storage you can write to; BI Tables are shaped for consumption by BI tools.
Create Table Creates a table in Peaka's own storage, in either family. The table starts empty; add columns with Add Column and load data with Import CSV.
Delete Table Permanently deletes a Peaka stored table and its data. There is no undo on this API.
List Table Columns Returns the columns of a Peaka stored table, with their data types and constraints.
Add Table Column Adds a column to a Peaka stored table. The data type is one of Peaka's seven storage types, and the not null and unique flags are enforced by Peaka rather than by the source.
Update Table Column Updates a column on a Peaka stored table: its display name, default value or constraints. Changing a data type on a column that already holds data is rejected where the values cannot be converted.
Delete Table Column Permanently deletes a column from a Peaka stored table, along with every value in it.
Import CSV Loads a CSV file into a Peaka table. The file is fetched from the URL you supply and posted as multipart form data alongside a JSON import configuration.
Get Sample CSV Returns a sample CSV showing the column layout Peaka expects when importing into a table. Use it to build a file that will import cleanly rather than discovering the column order by trial.

Queries

Execute Query Runs a query against a project and returns the rows. Four modes are available and they are mutually exclusive: run a saved query by its id or by its fully qualified name, run a raw SQL statement with bind parameters, or build a structured query from columns, tables, filters and ordering.
List Queries Returns the saved queries in a project, with their names, types and folder paths.
Create Query Saves a SQL query in a project so it can be run by name or id later. A Plain query runs on demand.
Get Query Returns a saved query by id, with its SQL, type, schedule and folder path.
Update Query Updates a saved query's name, SQL or schedule. This is a PUT, so send the full set of fields you want the query to end up with.
Delete Query Permanently deletes a saved query. Anything referencing it by id or qualified name stops resolving.
Move Query Moves a saved query to a different folder path. Intermediate folders are created automatically, so a path can be set before the folders exist.

Query Folders

List Query Folders Returns the query folders in a project as a flat list.
Get Query Folder Tree Returns the query folders as a nested tree rather than a flat list, which is the shape to use when rendering a navigator.
Create Query Folder Creates a query folder, either at the top level or beneath an existing one. Supply a Parent Folder ID to nest it.
Get Query Folder Returns a single query folder by id, with its name, path and contents.
Set Query Folder Contents Adds or removes queries from a folder. Peaka's own name for this route is Add/Remove Queries In/From Folder, so the body decides which; check the response's query list rather than assuming an add was additive.
Rename Query Folder Renames a query folder. The queries inside it are unaffected, though their displayed path changes.
Move Query Folder Moves a query folder to a different path, taking its queries and any subfolders with it.
Delete Query Folder Deletes a query folder. Check what it contains with Get Query Folder first, because the queries inside go with it.

Cache

Create Cache Starts caching a table in Peaka's own storage so queries are served from there rather than by calling the source every time.
Create Batch Cache Starts caching several tables in one call. Use it when bringing a whole schema into Peaka's storage rather than issuing one request per table.
Get Cache Settings Returns a cache's configuration, including both of its schedules and the table it covers.
Update Cache Settings Changes a cache's refresh schedules. Lengthening the incremental interval is the usual way to reduce load on a rate limited source.
Delete Cache Stops caching a table and discards the cached copy. Queries against that table start reaching the source again, which is slower and consumes the source's own quota.
Get Cache Status Returns the current state of one cache: whether a refresh is running, when it last completed and whether it failed.
List Cache Statuses Returns the state of every cache in scope, across a whole project or narrowed to one catalog or one schema. Use it to spot a cache that has stopped refreshing before a dashboard quietly goes stale.
Get Cache Execution History Returns the past refresh runs of a cache, with their durations and outcomes. Use it to diagnose a cache whose refreshes are failing or taking longer than the interval between them.
Refresh Cache Triggers a cache refresh immediately rather than waiting for its schedule. An Incremental refresh fetches only what changed; a Full refresh re reads the entire table from the source, which is the expensive one on a metered or rate limited connection.
Cancel Cache Refresh Cancels a cache refresh that is currently running. Choose the same type that is running: canceling an incremental update does not stop a full refresh and the reverse is also true.

Materialized Queries

List Materialized Query Statuses Returns the refresh state of every materialized query in a project. A materialized query that has stopped refreshing serves stale rows without any error, so this is the check that catches it.
Get Materialized Query Status Returns the refresh state of one materialized query, including when it last completed and whether the last run failed.
Refresh Materialized Query Recomputes a materialized query immediately rather than waiting for its schedule. Use it after a known upstream change, so a report does not have to wait for the next scheduled run.
Cancel Materialized Query Refresh Cancels a materialized query refresh that is currently running. The previously stored result is kept, so the query continues to serve the older rows.

Exports

Export Data Starts an asynchronous export of a saved query's results or of a catalog table, to CSV or JSONL, optionally gzipped.
List Exports Returns the exports in a project with their state and download links.
Get Export Returns the state of one export and, once it has finished, the artifacts to download. Poll it after Export Data, which returns only an id.
Cancel Export Cancels a running export. Any artifacts already produced are discarded.

Semantic Layer

Create Semantic Catalog Creates a semantic catalog, a curated layer over raw tables that gives Peaka's AI agent business meaning rather than column names.
Create Semantic Table Adds a table to a semantic catalog, mapping raw columns to business meaning so the AI agent can answer questions in the language people actually use.
Delete Semantic Table Removes a table from a semantic catalog. The underlying data is untouched; only the semantic mapping goes.
Share Semantic Catalog Shares a semantic catalog with other projects or users, so a curated model built once is available everywhere it is needed.
List Parametric Tables Returns the parametric tables defined on a catalog. A parametric table takes arguments at query time, which is how a source that needs a parameter (a date range, an account id) is exposed as something SQL can select from.
Create Parametric Table Defines a parametric table on a catalog: a table whose query takes arguments supplied at select time.
Delete Parametric Table Deletes a parametric table from a catalog. Peaka identifies the table in the request body rather than in the URL, so confirm the name against List Parametric Tables before calling.

Metadata and Agent Grounding

Get Project Metadata Returns the metadata Peaka holds about a project's data: table and column descriptions, relations and the settings that decide what the AI agent may use.
Refresh Project Metadata Rescans a project's sources and rebuilds its metadata. Run it after a schema change at the source, because until you do the AI agent and the semantic layer are working from the old shape.
Get Metadata Refresh Status Returns the state of a metadata refresh for one catalog. Poll it after Refresh Project Metadata, which is asynchronous.
Manage Metadata Refresh Callback Manages the webhook Peaka calls when a metadata refresh finishes, which is how a flow avoids polling for it. Get reads the current callback, Register sets one, Unregister removes it.
Update Metadata Sets metadata and AI usage settings at whichever level you choose: a whole catalog, one schema, or one table. Turning AI usage off for a catalog is how you keep a sensitive source out of natural language answers without disconnecting it.
Manage Categorical Values Generates or removes the list of distinct values Peaka holds for a column. Categorical values are what let the AI agent map a phrase in a question onto an actual value in the data, so generating them on a status or category column measurably improves its answers.
Generate Table Semantics Has Peaka generate semantic descriptions for a table's columns using AI, rather than writing them by hand. It is the fast way to give the agent a starting model over a large schema; review what it produces before relying on it.
Query Metadata Searches a project's metadata semantically, returning the tables and columns most relevant to a question. It is the retrieval step the AI agent itself uses, and calling it directly is how you check whether the agent can even see the data before blaming its answer.
Generate Sample Questions Has Peaka propose questions its AI agent can answer well against this project's data. Use it to seed a dashboard's suggested prompts, or to see what the agent believes it knows.
List Golden SQL Returns the curated example queries registered for a project. A golden SQL is a question paired with the query that correctly answers it, and the AI agent uses them as worked examples, so a handful of good ones improves its output more than a large schema does.
Create Golden SQL Registers a question and the query that correctly answers it, as a worked example for the AI agent. A handful of good ones improves natural language answers more than a large schema does.
Delete Golden SQL Removes a curated example query from a project. The agent stops using it as a worked example.
Get Catalog Relations Returns the relations recorded between tables in a catalog. Relations are what let the AI agent join tables correctly; without them it will answer single table questions well and multi table questions badly.
Add Metadata Relation Records a relation from a column to another table, so the AI agent knows how to join them. Sources without foreign keys (most SaaS APIs) have no relations until you add them here.
Update Metadata Relation Updates an existing relation between tables, addressed by its relation id.
Delete Metadata Relation Removes a relation between tables. The AI agent stops joining them, which is the fix when it is producing a join that does not make sense.

AI Agent

Chat With Agent Asks Peaka's AI agent a question in plain language about a project's data. The agent writes SQL against the project's catalogs and, by default, runs it and answers with the result.
List Agent Threads Returns the AI agent conversation threads in a project, with their display names. Use it to find a thread id to continue.
Get Agent Thread Returns one AI agent thread with its full message history, including the SQL the agent wrote at each step. Use it to audit how the agent arrived at an answer.
Rename Agent Thread Changes the display name of an AI agent thread, which is how a flow labels a conversation it started so a person can find it later.
Delete Agent Thread Permanently deletes an AI agent thread and its message history.

Tools and Embedding

Transpile SQL Rewrites a SQL statement from another database's dialect into the one Peaka executes. Use it to move an existing query from Postgres, BigQuery or Snowflake into Peaka without translating it by hand.
List Supported Drivers Returns the database drivers Peaka publishes for connecting BI and analysis tools directly to it over SQL, rather than through this REST API.
Get Driver Returns the download details for one of Peaka's SQL drivers, so a BI tool or a Python process can connect to Peaka as if it were an ordinary database.
Init Session Starts an embedded Peaka session and returns the token a browser needs to render Peaka's own interface inside your product.

Frequently Asked Questions

What can FlowRunner do with Peaka?

FlowRunner agents can run List Organizations, Get Organization, and List Workspaces in Peaka, plus 106 more actions.

Does connecting Peaka to FlowRunner require OAuth?

No. Peaka connects to FlowRunner with an API key, no OAuth flow required.

Can Peaka trigger a FlowRunner workflow automatically?

Peaka doesn't currently expose triggers in FlowRunner. It connects as an action step inside workflows started by another trigger.

Start building with Peaka

Free plan, no card required. Connect in minutes.

Start Building Free Talk to us