How the autario platform works
Connect your ad, social, shop and other business accounts once, and Claude, ChatGPT or any MCP client works with your live numbers and their history to analyze, report and build the apps you describe.
- All in one. Connectors, storage that keeps the history, the report your AI builds, the ready-made apps and Power BI in one place: no stitching a connector, a dashboard tool and a warehouse together in an IT project. 60 connectors and 10 data apps run on the same tables, and every one of them is read-only.
- Speed. The report you describe runs in minutes as an app on a link, not in a quarter as a ticket to IT. Your own app is one pasted HTML file that runs on a URL you can share; Social 360, Marketing Report, AI Visibility 360, LLM Costs read the connected accounts directly as ready-made examples.
- Simplicity. You pick a service and sign in, then say what the report should show. No template to wire, no warehouse to size, no query to write. Power BI and Excel read every table you own from one link, and a share link opens a report without a login.
- Flexibility. Any report, not the one a template chose: your AI builds the view you describe on your own numbers, and your AI agent answers questions on the same tables. 16 MCP tools let ChatGPT or Claude read the same tables on every plan.
autario is the head in a headless world: one place that reads every tool with an API.
- 10 data apps in the App Store run on that layer, each connector page names the apps that read it, and your own app is one pasted HTML file that runs on a URL you can share. The App Store
- 16 MCP tools let your AI agent find a dataset, read its schema, query it and publish an app, on every plan. The MCP tools
- One link lists every table you own for Power BI and Excel, and each row carries the CSV URL that streams the whole table. Power BI in one link
- 60 connectors with 447 read-only reports, each connector on its own page with every report, field and permission it uses. The connector catalogue
- Any other tool with an API is read by the generic REST connector: a URL, a method and a key. Any REST API
- The public dataset count is live on the engine status page, never typed into this sentence. Live engine status
Connector pages, for example: Meta Ads Performance, Google Ads Performance, Google Analytics 4, Shopify Store Reporting, Amazon Seller, LinkedIn Analytics.
Who it is for. Roles, not segments. Each line is what that person has after the connect.
- Marketing managers. Spend, revenue and ROAS per channel against the previous period, every morning, without a ticket to IT and without a dashboard to wire.
- E-commerce managers. Orders, ad spend and payouts from the shop and the ad platforms in one table per brand, with each currency kept apart and never silently converted.
- Strategy managers. One question across channels and public datasets, asked in ChatGPT or Claude against stored history, instead of a deck built from screenshots.
- Agency account managers. One page per client brand with a read-only link the client opens without a login, refreshed daily on a paid plan, and the same numbers in Power BI when they ask.
- Founders. The whole stack in one place on the free plan with your own LLM key: connectors, storage that keeps the history, the reports, the API and the apps your AI writes.
This page is the technical description of autario: what happens to data on the way in, what a connector is and what it is allowed to do, how the data leaves again, what runs on top of it, and what we can prove about any of it. Everything below is something that is running in production today. Where a thing is planned rather than built, it says so.
What happens to data on the way in
autario is solving manual reporting: the accounts connect once, the numbers land in one table that keeps its history, and your AI agent gets real data with its history and a place to run the apps it builds.
The expensive part of working with data from many sources is never the download. It is that every publisher has its own column names, its own country codes, its own idea of what a date is and its own way of telling you that a series ended. autario does that work once, at ingestion, so that a caller sees one shape.
- Schema detection
- Column names and types are detected from the parsed source rather than declared by hand, and the detected set is compared with the table that already exists. When they differ, the table is rebuilt around the new set while the dataset keeps its identity, so a link to it never breaks.
- Entity resolution
- A country is resolved to a canonical ISO-3 code, or it is left empty. It is never stored in the publisher's raw spelling, because a join key that is sometimes DE, sometimes DEU and sometimes Germany is worse than no join key at all. Resolution is decided per dataset in context: the same three letters can be a country in one table and a ticker in another, so the decision reads the whole column before it commits.
- Shadow columns
- Alongside the publisher's own columns, every row carries a normalized entity, a normalized time and a normalized value. Those three are what let one call join a World Bank series to a FRED series without anyone writing a mapping.
- Invariants before the write
- A full replace is checked before it is allowed to land: one row per entity and period, a time column that is an observation date rather than a publication stamp, a plausible row count measured in periods where the rows are periodic, and derived rows that tile their year. A violation refuses the ingest, leaves the old table in place and writes a finding, instead of quietly installing a truncated or duplicated table.
- A recorded changelog
- Structural change is classified rather than absorbed. A rename, a dropped column, a type change and a unit correction each get a dated entry with a plain sentence, the schema version on the metadata response moves with it, and anyone can read the history at /api/v1/public/datasets/:id/changelog without an account.
The same pipeline runs for public datasets and for the private tables your connectors write, which is the reason a connector table behaves like a public dataset everywhere else on the platform.
Correctness stays with the publisher. Where a source value looks wrong, it is flagged and not featured; it is never edited or nulled on its way through. A number you read here is the number the publisher published, and the page tells you where it came from and when it was last refreshed.
Connectors
A connector is a declaration, not a script. It states which endpoints to call, which fields to keep, how the provider pages its results, which scope each report needs and how often the whole thing should run. One generic request runner executes every one of them, which is why a new provider is a data change rather than a new code path.
- You pick the service and sign in. For the providers that use OAuth, autario operates the application and the consent screen, so there is nothing for you to register and no client secret to store.
- You choose the reports you want. Each one is a named table with a described shape, and the ones that need a setting you have not filled in are listed as skipped with the reason rather than failing quietly.
- The first run fetches the history the provider is willing to give, usually the last full window it supports.
- After that a paid plan refreshes it on a schedule, daily by default, and on the free plan it refreshes by click (daily from Lite); the button refreshes it on demand.
- The result is an ordinary table. You query it through the same API and the same MCP tools as any public dataset.
Every operation in every connector reads. Nothing posts, spends, cancels or changes anything in the account you connect. Where a provider only publishes a combined read and write scope for the numbers a report needs, the report list in the setup form shows exactly which calls will run, and a test refuses the build if a preset's source ever grows a write verb.
Refreshes are additive. Rows are matched on the provider's own identifier and updated in place, so a post that gained likes overnight gets a new number and a post the provider stopped returning keeps its last known values instead of disappearing from your history. When a provider renames or retypes a column, the change is widened where it can be widened losslessly and recorded in the dataset changelog either way.
Provider rate limits are declared per operation and obeyed by the runner, and a 429 with a Retry-After header is honoured rather than retried blindly. A report that fails for one value out of ten keeps the nine and reports the one, so a single bad metric does not cost you the whole run.
How data gets out again
There is one read model and four ways to reach it. The numbers are identical through all of them, because they are the same query underneath.
- REST
- A versioned public API at /api/v1/public. The public catalogue needs no key and no account. Your own data needs an API key and secret sent as headers. The whole surface is described by an OpenAPI document at /api/v1/openapi.json.
- MCP
- 16 tools over a remote endpoint at /mcp, or locally through the autario-mcp package. Responses default to a token-oriented wire format that is substantially smaller than pretty JSON on tabular data. This is the path an assistant takes.
- Power BI and Excel
- The REST endpoints are plain HTTP and return JSON, which is what the Web connector in both products expects. You paste a URL, expand the data list into a table and refresh it on the schedule your workbook already has.
- CSV
- An export endpoint per dataset for the moments when a file really is the answer. It streams rather than buffering, so the size of the table is not the size of the request.
Reading is not only rows. Finished statistics are computed on the server and returned as a small object: mean, median, quartiles, growth, rolling windows, correlation with a p-value, regression, seasonal decomposition. That is the difference between asking a question and downloading a table to answer it yourself.
Ask for one entity and one time range and you get exactly that, not the table it came from. Measured on 2026-09-04: query_dataset(dataset_id, filter: ["countryiso3code:eq:DEU", "date:gte:2010", "date:lte:2020"], sort: "date:asc") returns 11 rows, 527 tokens. The same 11 rows from the publisher's own API cost 840 tokens and need the indicator code, the entity code and the provider's date syntax before the call can be written (2026-09-09). Pasting the same period for all 265 entities instead costs 2,915 rows, 208,134 tokens, 395 times more. Token counts are exact, counted with the OpenAI o200k tokenizer.
- The autario call, TOON: 11 rows, 527 tokens.
- The same 11 rows from the publisher's own API, JSON: 840 tokens, and the call needs the indicator code SL.UEM.TOTL.ZS, the entity code DEU and the syntax date=2010:2020 before it can be written at all.
- The whole table for the same period instead, JSON: 2,915 rows across 265 entities, 208,134 tokens.
Measured on 2026-09-04 against Unemployment Rate by Country (World Bank), published by World Bank.
What runs on top
A data app on autario is a small self-contained web bundle. It runs in a sandboxed frame with a hard content security policy and no outbound network of its own, and it reaches data through a gated bridge rather than through fetch. That is what makes it safe to run somebody else's app against your own numbers.
The lifecycle is self-serve, with a content check in the publish call instead of a review queue: create the app, upload its bundle, look at a preview URL, publish it. Publishing moves it to unlisted, where anyone with the link can open it, or to public, where it gets a tile on its shelf in the app store, next to the apps that do the same job. Every one of those steps is an MCP tool as well as an HTTP endpoint, which is the point: an assistant can carry out the whole thing without a canvas and without a person clicking through a builder.
autario's own apps are built the same way and consume the same public API. The chart builder, the country and company hubs, AI Visibility 360, Social 360 and LLM Costs are not privileged code paths; they are the proof that the platform boundary is real.
What we can prove
Two questions decide whether a company may use a vendor at all, and both of them deserve a page rather than a promise.
- Every read, query and export of your own data writes one row in your account's access log: who did it, whether they were you, an invited reader, an API key or an assistant over MCP, which dataset or report, how many rows and when. You read that log yourself under Account and Access. It is not a report you have to ask us for.
- Ownership is enforced in the SQL of every query rather than in the interface. A request for something that belongs to somebody else answers 404, not an empty list.
- All application servers, the database and the daily backups run on AWS in Frankfurt, Germany. Customer data is not replicated to another region.
- OAuth tokens, connector credentials and any model key you paste are encrypted before they are written, and a stored secret is never sent back to a browser.
- Deploys are blue-green: a new container has to pass a health gate before traffic moves to it, and the previous one keeps serving if it does not.
There is also a list of what we do not have yet, and it is on the same page as the rest: no SSO, no SAML, no SCIM, no SOC 2 and no ISO 27001, no penetration test, no warehouse push and no self-hosting. If one of those is a hard requirement for you, that page will save you a meeting.
Questions
- Do I have to register my own OAuth application with each provider?
- No. For the providers that use OAuth, autario operates the application and the consent screen, so you sign in and pick what to share. A handful of providers issue a personal token instead, and for those you paste the token once. The setup form for each connector says which of the two it is before you start.
- Can a connector change anything in my account?
- No. Every operation in every connector is a read. Where a provider only offers a combined read and write scope for the numbers a report needs, the report list shows exactly which calls run, and a test refuses the build if a connector definition ever grows a write verb.
- Where does my data physically live?
- On AWS in Frankfurt, Germany, together with the database and the daily backups. It leaves those servers only towards the subprocessors listed on the security page, and it is never pooled into a product other customers can see.
- What happens when a provider changes its API?
- A widened column, for example an integer that starts arriving as a decimal, is migrated in place without losing a row. A rename or a dropped column is recorded in the dataset changelog with a date and a sentence, and the schema version on the metadata response moves, so a consumer can notice. Nothing changes structure silently.
- Can I use autario without writing code?
- Yes. Connecting a service, picking reports and reading the result are interface actions. The API and MCP exist for the cases where a person is not the one asking, which increasingly means an assistant.
What autario is
autario is the data layer for your AI agents: connect your ad, social, shop and analytics accounts once, and Claude, ChatGPT or any MCP client works with your live numbers, their history and public datasets to analyze, report and build the apps you describe.
Best for: agencies that report across Meta Ads, Google Ads, GA4, Search Console and LinkedIn for several brands; merchants selling on Shopify and Amazon who want orders, ad spend and payouts in one table; teams tracking OpenAI and Anthropic spend; brands tracking how often ChatGPT, Claude and Perplexity mention them.