Authentication
There are three credentials on autario and they exist for three different callers. An account key identifies you. An MCP bearer identifies the assistant acting as you. A scoped app token identifies one app and can only do what its scope says. Mixing them up is the most common first mistake, so this page says exactly which one each door wants.
Public data needs no credential
Everything under the public prefix answers anonymous requests, and the browser can call it directly: those endpoints send an open CORS header and no credentials, so a page on localhost, a file URL or any deployed site can fetch them with plain fetch. Two limits apply. Send no cookies, because a credentialed request falls back to the autario.com allowlist and the browser will block it, and call POST endpoints from a server, because they are not yet open to other origins.
curl 'https://autario.com/api/v1/public/datasets/<id>/data?limit=5'
If a public path answers 401 you have hit a real endpoint that needs a key rather than a routing mistake. The body names the headers that work. An unknown path under the public prefix answers 404 with an error_code of unknown_endpoint, never an auth error, so you can tell a typo from a permission problem without reading prose.
Account keys for REST
Private endpoints, the write API and the whole developer portal take two headers. The key identifies your account and the secret proves ownership; the secret is stored hashed, so it is shown once when you create the pair and cannot be retrieved afterwards. Create and revoke pairs on your account page.
x-api-key: <your-key>
x-api-secret: <your-secret>
An API key in an Authorization bearer header does not authenticate the REST API. That header belongs to MCP. Session cookies also work on the developer portal routes, which is what the portal UI itself uses, so a route may accept either.
MCP: local and remote
The local server runs over stdio and reads its credentials from the environment, which is why the client config in the quickstart passes them as env vars. It is a thin bridge to the remote endpoint: it sends the pair as the x-api-key and x-api-secret headers, and the remote server runs every tool as the owner of that key. Read-only tools work without any credential; the write tools need the pair.
AUTARIO_API_KEY=<your-key>
AUTARIO_API_SECRET=<your-secret>
npx autario-mcp
The remote endpoint is a StreamableHTTP MCP server at the /mcp path. It authenticates with a bearer token or with the API key pair as x-api-key and x-api-secret headers, and a client that supports OAuth will run the authorization flow for you and store the result. Anonymous callers still get the read-only half of the tool list, so a client can connect first and authorize later; the write tools answer with an authentication refusal until it does.
Identity on MCP is never a tool argument. The bearer decides who the caller is, so an assistant cannot pass someone else's user id, and every write it performs runs through the same controller and the same limits your own REST call would.
Scoped API keys
An app that reads data on behalf of a user never holds an account key. Instead you create a scoped API key once and keep it server-side; the sandbox host replays it against the data proxy. The scope names the operations and, optionally, the exact dataset ids the key may touch, and anything outside it is refused rather than filtered.
POST /api/v1/proxy/token
{ "name": "sparkline reader",
"scope": { "ops": ["datasetMeta", "datasetData"], "datasets": ["<uuid>"] } }
The key secret is returned exactly once when you create it and is not retrievable afterwards. List your API keys on the developer portal to see what exists and delete what you no longer need. A key is bound to your account, so deleting it stops every app that was using it.
This is why a sandboxed app is safe to run against private data: the bundle in the iframe has no network of its own, cannot see the key, and asks the host by message passing. The host enforces the manifest scope before it ever reaches the proxy.
Rate limits and tracing
There are two separate per-IP budgets, one for data and one for documentation, both reported on every response through the standard rate-limit headers, which are exposed to JavaScript. Reading the documentation does not spend the data budget, and authenticated callers skip the data budget entirely.
Every response carries a request id header. Keep it when something goes wrong: it is how a specific request is found in the server logs, and an inbound id you supply is honoured and propagated, so your trace id and ours can be the same string.