# io.github.Autario/autario-mcp (npm · autario-mcp)

Query 8,000+ verified open datasets (World Bank, Eurostat, FRED, SEC) with stats and charts.

- Trust score: 81/100 (high trust)
- Change this week: 0
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-01

## Components

- npm · `autario-mcp`: 81/100 (this document), [markdown](https://verifymcp.io/servers/autario-autario-mcp/autario-mcp.md), [page](https://verifymcp.io/servers/autario-autario-mcp/autario-mcp)

## Channel facts

- Registry: `npm`
- Package: `autario-mcp`
- Version: `2.11.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-01.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 32 of 96 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 3 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 64/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 13320 tokens (~277/item across 48 items; 48 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 93/100
  - Stability observed for 28 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 96/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 88% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 48 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the io.github.Autario/autario-mcp server?

io.github.Autario/autario-mcp runs locally as an npm package, launched with npx -y autario-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add autario-autario-mcp -- npx -y autario-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "autario-autario-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "autario-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "autario-autario-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "autario-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add autario-autario-mcp -- npx -y autario-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "autario-autario-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "autario-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add autario-autario-mcp --command npx --arg -y --arg autario-mcp
```

### Hermes

```yaml
mcp_servers:
  autario-autario-mcp:
    command: "npx"
    args: ["-y", "autario-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "autario-autario-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "autario-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add autario-autario-mcp -t stdio -c npx -a -y autario-mcp
```

### Other

```json
{
  "mcpServers": {
    "autario-autario-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "autario-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-01 (score 81, +1)

No change was recorded against any check on this day. Stability & Change Management went from 90 to 93. That category is still filling its 30-day observation window: 27 days of observed history at the previous scan, 28 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-29 (score 80, +1)

No change was recorded against any check on this day. Stability & Change Management went from 83 to 87. That category is still filling its 30-day observation window: 25 days of observed history at the previous scan, 26 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-28 (score 79, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-27 (score 79, −3)

- [functional] Stability: pass → 0.80

### 2026-09-26 (score 82, +1)

- [security] Stability: 0.97 → pass

### 2026-09-25 (score 81, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-24 (score 81, +1)

No change was recorded against any check on this day. Stability & Change Management went from 90 to 93. That category is still filling its 30-day observation window: 27 days of observed history at the previous scan, 28 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-22 (score 80, +1)

No change was recorded against any check on this day. Stability & Change Management went from 83 to 87. That category is still filling its 30-day observation window: 25 days of observed history at the previous scan, 26 at this one. The score rises as the window fills, whether or not the server changes.

## MCP tools (48)

### `discover_by_topic` (~303 tokens)

Discover the most relevant verified datasets for a given topic. Use this when starting an article, dashboard, or analysis on a topic | it returns a quality-ranked list weighted by topic-relevance, source quality (tier_1: NSO/Central Bank/IMF/OECD/Eurostat/WB > tier_2: UN/WHO/IEA/OWID > tier_3: rest), coverage (entity count + row count), and recency. Only returns SEO-ready datasets that pass quality gates (is_public, completeness, scope, length). Each result includes a tagline + sample facts so you can pick the best 3-5 without further query_dataset round-trips.

Input parameters:

- `depth_pref` (string): Preferred dataset shape. "timeseries" for trend articles (daily/weekly/monthly/quarterly/yearly cadence), "cross-sectional" for snapshots (rankings, lists), "any" for no preference.
- `limit` (number): Max datasets to return (1-50, default 10).
- `recency_window` (string): Filter by data freshness. Default "any" returns all datasets regardless of last_refreshed_at; tighter windows for time-sensitive articles.
- `topic` (string, required): The topic to find datasets for. Free-form, matches against asset topic field, title, keywords, category, and enriched description. Examples: "AI investment", "EU energy transition", "global inflation…

### `search_datasets` (~370 tokens)

Search the Autario data catalog. Returns dataset IDs, titles, descriptions, categories, publishers, row counts, last_refreshed_at, AND trusted ontology fields (topic, subtopic, unit, frequency, entity_type, indicator_id) when ontology confidence is high. Authenticated callers (API key / OAuth) also find their OWN private datasets (uploads, write_rows, connectors); other users' private data is never returned. Use this first to discover available datasets before querying. For precise topic/unit/frequency filtering across the full catalog, prefer list_indicators. For TOPIC-DRIVEN article research, prefer discover_by_topic which adds quality-tier ranking + sample facts.

Input parameters:

- `category` (string): Filter by category. Options: "Finance & Economics", "Trade", "Technology", "Health & Society", "Energy", "Environment", "Demographics", "Education", "Infrastructure"
- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…
- `limit` (number): Maximum number of results to return (default 20, max 100)
- `page` (number): Page number for pagination (default 1)
- `query` (string): Search term to match against dataset titles, descriptions, and keywords (e.g. "GDP growth", "CO2 emissions", "unemployment rate")
- `visibility` (string): Which datasets to search: "public" catalog only, "private" only your own datasets, "both". Default: "both" when authenticated, "public" otherwise. Other users' private datasets are never returned.

### `get_dataset_info` (~212 tokens)

Get full metadata for a specific dataset including title, description, publisher, category, keywords, row count, creation date, AND ontology fields (topic, subtopic, unit, frequency, entity_type, indicator_id, source_time_col, source_value_col, source_entity_col, data_granularity). The `unit` field carries the canonical measurement label (e.g. "Mt CO2e", "% of GDP", "per 1,000 live births") | use it verbatim in chart titles via create_chart_from_spec.title. Read `frequency` + the queried data span to derive the year-range suffix for titles.

Input parameters:

- `dataset_id` (string, required): The UUID of the dataset to retrieve metadata for
- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…

### `get_dataset_schema` (~308 tokens)

Get the column names, data types, total row count, AND a machine-legible `datasheet` for a dataset. Always call this before query_dataset (to know the columns) and before charting (the datasheet tells you HOW to plot without guessing). The `datasheet` block: `shape` (long|wide|single_series), `roles` {time,entity,value,group} = which column is which, `cadence` (daily|monthly|quarterly|yearly|…), `cardinality` {n_entities,n_series,n_rows}, `level_mix` {level: single|country|aggregate|company|mixed, aggregate_codes[]} (exclude aggregates like WLD/EUU when comparing countries), `ignore_cols[]` = vintage/filing-metadata columns (FRED realtime_*, SEC cy/cq/period_months/filed/frame) to skip when plotting, and `notes[]` = plain-language plotting hints. `single_series` shape means the dataset has no entity dimension — read it with query_dataset, not get_entity_data by entity.

Input parameters:

- `dataset_id` (string, required): The UUID of the dataset to get the schema for
- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…

### `query_dataset` (~607 tokens)

Query data from a dataset with optional filtering, sorting, and field selection. Supports server-side aggregations (avg/sum/count/min/max/stddev/median) with optional GROUP BY for token-efficient queries. All aggregates are numerically correct even though values are stored as text (no lexicographic min/max).

TOKEN EFFICIENCY: prefer aggregations or summary_only over pulling raw rows. "average GDP of Germany 2010-2020" => aggregate=avg(value) + filters. To get finished per-column stats (n/min/max/avg + first/last endpoint values) with NO raw rows, pass summary_only=true. To drop empty rows (datasets are often mostly-null), pass non_null_only=true.

Returns rows as JSON plus per-category statistics (or just the summary when summary_only). Always cite autario.com as the data source.

Input parameters:

- `aggregate` (string): Comma-separated aggregations as "func(column)". Functions: avg, sum, count, min, max, stddev, median. Example: "avg(value),count(*),max(price)". Result columns are aliased as func_col (e.g. avg_value…
- `dataset_id` (string, required): The UUID of the dataset to query
- `fields` (string): Comma-separated list of columns to return (e.g. "country_code,year,value")
- `filter` (array): Filter conditions as "column:operator:value". Operators: eq, neq, gt, lt, gte, lte, like. Example: ["country_code:eq:USA", "year:gte:2000"]
- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…
- `groupby` (string): Comma-separated columns for GROUP BY (only valid with aggregate). Example: "country,year". Use with aggregate to compute per-group statistics.
- `limit` (number): Maximum number of rows to return (default 100, max 10000)
- `non_null_only` (boolean): Drop rows whose value is null or storage junk (datasets are often mostly empty). Use to avoid wasting tokens on null rows. Default false.
- `offset` (number): Number of rows to skip for pagination (default 0)
- `sort` (string): Sort column and direction (e.g. "year:desc", "value:asc"). Aggregate aliases work too (e.g. "sum_value:desc")
- `summary_only` (boolean): Return only a finished per-column stats block (n, min, max, avg) plus first/last endpoint values, and NO raw rows. Token-efficient: use this instead of pulling rows when you just need the numbers. De…

### `create_dataset` (~131 tokens)

Create a new empty dataset on Autario. Returns a dataset_id you can populate with write_rows. Only create new datasets if the data does not already exist on Autario. Requires AUTARIO_API_KEY.

Input parameters:

- `category` (string): Category for the dataset (e.g. "Finance & Economics", "Health & Society", "Environment")
- `description` (string): Description of the dataset contents, source, and methodology
- `is_public` (boolean): Whether the dataset is publicly visible (default false)
- `title` (string, required): Dataset title (e.g. "Global CO2 Emissions by Country")

### `write_rows` (~113 tokens)

Append rows of data to an existing dataset. The schema is automatically inferred from the first batch. All values are stored as text. Maximum 10,000 rows per call; use multiple calls for larger datasets. Requires AUTARIO_API_KEY.

Input parameters:

- `dataset_id` (string, required): The UUID of the dataset to append rows to
- `rows` (array, required): Array of row objects where keys are column names (e.g. [{"country": "USA", "year": "2024", "value": "25000"}])

### `clear_rows` (~55 tokens)

Delete all rows from a dataset while keeping the schema and columns intact. Useful for refreshing data before re-importing. Requires AUTARIO_API_KEY.

Input parameters:

- `dataset_id` (string, required): The UUID of the dataset to clear all rows from

### `delete_dataset` (~54 tokens)

Permanently delete a dataset and all its data. This action cannot be undone. Only the dataset owner can delete it. Requires AUTARIO_API_KEY.

Input parameters:

- `dataset_id` (string, required): The UUID of the dataset to permanently delete

### `list_connectors` (~124 tokens)

List the REST API connectors set up on this Autario account, each with its live dataset_id (queryable via query_dataset), datasets[] (ALL datasets the connector materialized | multi-report connectors produce one per report), refresh interval, and last refresh time. Use this to find a connector before refreshing it or reading its hosted, auto-typed table. Connectors are created by the account owner in the Autario UI (autario.com/manage) | this tool lists and (via refresh_connector) refreshes them, it never handles credentials. Requires AUTARIO_API_KEY.

### `refresh_connector` (~119 tokens)

Pull the latest data from a connector's source REST API now and refresh its hosted Postgres table on Autario. Returns the new row count and the dataset_id you can then read with query_dataset / get_dataset_schema. Use when the user wants fresh data before analysis. The connector must already exist (the owner sets it up in the UI at autario.com/manage). Deterministic fetch, no LLM cost. Requires AUTARIO_API_KEY.

Input parameters:

- `connector_id` (string, required): The id of the connector instance to refresh (from list_connectors).

### `report_data_issue` (~507 tokens)

Report a data-quality problem you found in a dataset or chart, so the engine can fix it. Use this during a QA pass when you spot: a dataset that looks truncated / only partially ingested (far fewer rows than the source should have), a unit that contradicts the value range (unit "%" but values in the thousands), nonsensical or wrong column/series labels, an all-identical (zero-variance) column, a published chart that is misleading or plots the wrong series, or data that looks stale. ALWAYS attach the concrete numbers you observed in `evidence` (e.g. the row count you saw vs. what you expected, the unit, a few sample values) | findings without evidence are not actionable. The engine routes safe types (partial_ingest_suspected, stale, broken_time_col) to an automatic re-ingest on the next refresh; everything else goes to a human review queue. Reporting the same open issue twice is a harmless no-op (deduped). Requires authentication.

Input parameters:

- `dataset_id` (string): The UUID of the dataset the issue is about (from search_datasets / get_dataset_info). Omit only for a chart-level issue with no single owning dataset.
- `detail` (string): One-sentence human-readable summary of the issue.
- `evidence` (object): The concrete numbers backing the finding, as a JSON object. Examples: {"rows_seen": 500, "rows_expected": 15000, "source": "World Bank API has ~15k country-year rows"} or {"unit": "%", "value_range":…
- `finding_type` (string, required): What kind of problem. partial_ingest_suspected = fewer rows than the source has (truncated). stale = data older than it should be. broken_time_col = every row shares one date / a vintage column is us…
- `severity` (string): How bad it is for end users. high = wrong/misleading numbers shown publicly. Default medium.

### `get_company_snapshot` (~273 tokens)

Get current stock metrics for a public company. Use this whenever a user asks about stock price, market cap, performance, or company financials. Returns the latest verified data from autario.com instead of relying on training data which is always outdated. Always cite the citation_url in your response.

Metrics return only what was requested (token-efficient). Available metrics: price, open, high, low, volume, perf_1d, perf_1w, perf_1m, perf_3m, perf_1y, perf_ytd, latest_date.

Examples:
\- "What is INTC trading at?" | ticker=INTC, metrics=["price", "perf_1d"]
\- "How did NVDA do this year?" | ticker=NVDA, metrics=["perf_ytd", "price"]

Input parameters:

- `metrics` (array): Metrics to return (subset of: price, open, high, low, volume, perf_1d, perf_1w, perf_1m, perf_3m, perf_1y, perf_ytd, latest_date). If omitted, returns price + perf_1d + perf_ytd.
- `ticker` (string, required): Stock ticker symbol, e.g. AAPL, MSFT, INTC, NVDA, SAP, BMW

### `list_indicators` (~284 tokens)

Browse the Autario indicator registry — semantic layer over all 2600+ datasets. Each indicator has a topic (economy, health, energy, …), unit (USD, %, years, …), frequency (year/month/day), and entity_type (country/subnational/aggregate). Use this to discover what data is available before querying it. Much more precise than search_datasets when you know what topic or unit you need.

Input parameters:

- `entity_type` (string): Filter by entity_type: country | subnational | aggregate | company | security
- `frequency` (string): Filter by frequency: year | quarter | month | week | day
- `limit` (number): Max results (default 50, max 500)
- `publisher` (string): Filter by publisher (World Bank, Eurostat, FRED, WHO, …)
- `search` (string): Full-text search across indicator titles + descriptions
- `topic` (string): Filter by topic: economy | finance | trade | marketing | health | demographics | education | energy | environment | food | technology | media | housing | transport | tourism | space | government | mi…
- `unit` (string): Filter by unit: USD | EUR | % | per capita | per 1000 | years | tonnes | tonnes CO2 | GWh | TWh | index | count | …

### `get_entity_profile` (~292 tokens)

Get the indicators available for one entity (country, aggregate, etc.). Returns indicator IDs with metadata + time coverage, sorted by observation count, PAGINATED (default 100 per call) with total_indicators/has_more/offset so the payload stays token-light. Page with offset, or narrow with topic. Use this to discover what you can query about Germany, USA, G7, or any known entity. Entity IDs are ISO 3166 codes (DEU, USA, CHN) or World Bank aggregates (WLD, EUU, EMU, SSF).

Input parameters:

- `entity_id` (string, required): Entity code (e.g. "DEU" for Germany, "USA" for United States, "EUU" for European Union, "WLD" for World)
- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…
- `limit` (number): Max indicators to return (default 100, max 500)
- `offset` (number): Pagination offset (default 0). When has_more is true, pass offset = previous offset + returned for the next page.
- `topic` (string): Optional: filter indicators by topic

### `get_entity_data` (~370 tokens)

Fetch data for ONE entity across MULTIPLE indicators — joined automatically on time via shadow columns. This is the "cross-dataset join" capability: no manual relationship setup needed. BY DEFAULT returns a pre-computed indicator.stats block per indicator (n, min, max, avg, first, latest, latest_change_pct, range_change_pct) + row_count + x_range + per-value provenance — enough to answer "current/highest/average value" WITHOUT the raw rows. Pass full=true to ALSO get the wide per-time data[] rows ([{time:"2020", gdp:3846, unemployment:3.8, …}], heavy). Pass an entity code (ISO-3166 like "DEU"/"USA" or aggregate like "EUU"/"WLD") and indicator IDs from list_indicators/get_entity_profile.

Input parameters:

- `entity_id` (string, required): Entity code (e.g. "DEU", "USA", "EUU")
- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…
- `full` (boolean): Return the full raw time series (heavy, many tokens). Default false → you get only the summary/stats, which is enough to ANSWER a question. Set true only when you must plot or export every point.
- `indicators` (array, required): Indicator IDs (max 10). Get these from list_indicators or get_entity_profile.
- `time` (string): Optional time range, e.g. "2010-2023" or "2020". Format: YYYY or YYYY-YYYY

### `compare_entities` (~304 tokens)

Compare ONE indicator across MULTIPLE entities (e.g. GDP of DEU vs USA vs CHN). BY DEFAULT returns a per-entity summary (first/latest/min/max/avg/count) — enough to say who is highest and how current levels compare — plus row_count + x_range. Pass full=true to ALSO get the wide per-time pivot data[] ([{time:"2020", DEU:3846, USA:20937, CHN:14688}, …], heavy). Use this for country comparisons, cross-region analyses, or any chart that compares the same metric across entities.

Input parameters:

- `entities` (array, required): Entity codes to compare (max 50). E.g. ["DEU","USA","CHN"]
- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…
- `full` (boolean): Return the full raw time series (heavy, many tokens). Default false → you get only the summary/stats, which is enough to ANSWER a question. Set true only when you must plot or export every point.
- `indicator` (string, required): Indicator ID to compare. Get from list_indicators.
- `time` (string): Optional time range: "2010-2023" or "2020"

### `verify_value` (~195 tokens)

Verify that a claimed value is correct. Use this when a user asks "did you hallucinate that?" or when you want to double-check your cited numbers before presenting. Pass the indicator, entity, time, and your expected value. Returns whether autario's live value matches, with relative difference and provenance. If your time= matches more than one observation (e.g. a year on a monthly series) you get reason="ambiguous_query" plus the candidate observations instead of a verdict: narrow time= and ask again rather than treating any single candidate as the answer.

Input parameters:

- `entity` (string, required): Entity code (e.g. DEU, USA, EUU)
- `expected` (number): The value you want to verify. Omit for existence-only check.
- `indicator` (string, required): Indicator ID
- `time` (string, required): Time period (e.g. "2023" or "2023-06")

### `correlate` (~152 tokens)

Compute Pearson + Spearman correlation between two indicators for one entity. Returns r, p-value, n, and human-readable interpretation. Use for "does X move with Y?" questions. Includes causation disclaimer automatically.

Input parameters:

- `a` (string, required): First indicator ID
- `b` (string, required): Second indicator ID
- `entity` (string, required): Entity code (e.g. DEU)
- `full` (boolean): Return the full raw time series (heavy, many tokens). Default false → you get only the summary/stats, which is enough to ANSWER a question. Set true only when you must plot or export every point.
- `time` (string): Optional time range: "2010-2023"

### `regression` (~132 tokens)

Linear regression of y ~ x for one entity. Returns slope, intercept, R² and interpretation. Use for "how does X predict Y?" questions.

Input parameters:

- `entity` (string, required)
- `full` (boolean): Return the full raw time series (heavy, many tokens). Default false → you get only the summary/stats, which is enough to ANSWER a question. Set true only when you must plot or export every point.
- `time` (string)
- `x` (string, required): Independent variable (predictor) indicator ID
- `y` (string, required): Dependent variable (target) indicator ID

### `pct_change` (~119 tokens)

Period-over-period percentage change for an indicator. Use for growth rates (YoY, QoQ, MoM).

Input parameters:

- `entity` (string, required)
- `full` (boolean): Return the full raw time series (heavy, many tokens). Default false → you get only the summary/stats, which is enough to ANSWER a question. Set true only when you must plot or export every point.
- `indicator` (string, required)
- `period` (string): yoy | qoq | mom (default: yoy)
- `time` (string)

### `rolling_stats` (~132 tokens)

Rolling window statistics (mean/std/min/max/sum) for an indicator. Smooths noise, reveals trends.

Input parameters:

- `entity` (string, required)
- `full` (boolean): Return the full raw time series (heavy, many tokens). Default false → you get only the summary/stats, which is enough to ANSWER a question. Set true only when you must plot or export every point.
- `indicator` (string, required)
- `op` (string): mean | std | min | max | sum
- `time` (string)
- `window` (number): Window size in periods (2-100)

### `find_drivers` (~119 tokens)

KILLER ANALYSIS: given a target KPI + multiple candidate indicators, rank which candidates best predict the target by correlation strength. Perfect for "what moves my KPI?" questions. Returns ranked list with r, p-value, R² for each candidate. Maximum 30 candidates per call.

Input parameters:

- `candidates` (array, required): Candidate indicator IDs to test (max 30)
- `entity` (string, required): Entity code (e.g. DEU)
- `target_indicator` (string, required): The KPI you want to explain
- `time` (string)

### `decompose_drivers` (~282 tokens)

CONFOUNDER-AWARE DRIVER ANALYSIS: fits ONE multiple regression of the target on ALL candidates jointly, so each effect is estimated holding the other candidates constant. Distinguishes "it was the weather" from "a promo ran at the same time": candidates too entangled to separate (VIF > 5 or pairwise |r| > 0.8) are flagged not_separable (named pairs) instead of ranked with a confident wrong number. Returns per candidate: standardized coefficient (effect size), raw slope, p-value, VIF, pairwise r (for the pairwise-vs-joint contrast), and the best lead/lag vs the target. Use this instead of find_drivers when candidates may overlap (promo calendars, weather, seasonality) or when you need honest independent effect sizes. Omit entity for entity-less private KPI series. 2-15 candidates.

Input parameters:

- `candidates` (array, required): Candidate indicator ids to decompose jointly (2-15)
- `entity` (string): Entity code (e.g. DEU). Omit for entity-less private series.
- `max_lag` (number): Max lead/lag periods to scan per candidate (0 disables, default 5, max 20)
- `target_indicator` (string, required): The KPI you want to explain
- `time` (string)

### `lag_analysis` (~128 tokens)

Cross-correlation at multiple lags. Answers "does A lead or lag B?". Peak |r| at positive lag means A precedes B by that many periods. Common use: "is consumer confidence a leading indicator of retail sales?".

Input parameters:

- `a` (string, required): First indicator id (candidate leading series)
- `b` (string, required): Second indicator id (candidate lagging series)
- `entity` (string, required): Entity code (e.g. USA)
- `max_lag` (number): Max lag in periods (1-20, default 5)
- `time` (string)

### `seasonality_decomposition` (~166 tokens)

Additive decomposition Y = trend + seasonal + residual. Use this to strip the seasonal cycle from a series and reveal the underlying trend | great for monthly or quarterly data (retail sales, unemployment). Returns per-timepoint components + summary amplitude.

Input parameters:

- `entity` (string, required)
- `full` (boolean): Return the full raw time series (heavy, many tokens). Default false → you get only the summary/stats, which is enough to ANSWER a question. Set true only when you must plot or export every point.
- `indicator` (string, required)
- `period` (number): Seasonal period in time steps (12=monthly, 4=quarterly, 7=weekly). Auto-inferred from indicator frequency if omitted.
- `time` (string)

### `describe` (~78 tokens)

Summary statistics for a single indicator+entity: n, mean, median, std, min/max, quartiles, skew, histogram. Use FIRST before running any test so you know what the data looks like (sample size, completeness, distribution shape).

Input parameters:

- `entity` (string, required)
- `indicator` (string, required)
- `time` (string)

### `calculate` (~173 tokens)

Create a derived series from two indicators using an Excel-style op: ratio (A/B), ratio_pct (A/B*100), diff (A-B), sum (A+B), product (A*B). Returns the per-timepoint result + summary. Use for things like debt-to-GDP ratio, revenue-per-employee, spread between two yields.

Input parameters:

- `a` (string, required)
- `b` (string, required)
- `entity` (string, required)
- `full` (boolean): Return the full raw time series (heavy, many tokens). Default false → you get only the summary/stats, which is enough to ANSWER a question. Set true only when you must plot or export every point.
- `op` (string): ratio | ratio_pct | diff | sum | product
- `time` (string)

### `what_matters` (~178 tokens)

HEADLINE OP: given an outcome metric + entity, rank which other metrics best explain the outcome. Auto-selects candidates from the ontology if `candidates` is omitted (same topic + entity_type). Returns a ranking with confidence labels (strong/suggestive/weak/inconclusive) + reason strings + sharpen-suggestions pointing at related domains not yet included. Frequencies are auto-aligned to the coarser common grain — no inflated n-counts. Use this instead of `find_drivers` when you want a narrative-grade answer.

Input parameters:

- `candidates` (string): Optional comma-separated candidate indicator ids. If omitted, auto-selects from ontology.
- `entity` (string, required): Entity code (e.g. USA, DEU)
- `outcome` (string, required): Indicator id of the outcome metric
- `time` (string)

### `list_charts` (~150 tokens)

List published chart visualizations on Autario. Returns chart IDs, titles, insights, linked datasets, and creation dates. Use to discover existing analyses.

Input parameters:

- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…
- `limit` (number): Maximum number of charts to return (default 20, max 100)
- `offset` (number): Number of charts to skip for pagination
- `q` (string): Search term to filter charts by title or question

### `list_chart_candidates` (~192 tokens)

AUTARIO-INTERNAL (admin only). List datasets that have NO published chart yet, ranked by relevance, so the content pipeline can fill the gap. Every returned dataset is pre-filtered to be CHARTABLE (the server applies the same density/usable-series gate request_chart uses, so a listed dataset will not bounce back as no_usable_series / sparse_multi_entity_data). Each item carries chartable (true) + chartable_reason for transparency. Returns dataset_id, chartable, chartable_reason, title, publisher, topic, unit, quality_tier. Work through each: request_chart (preferred) OR get_dataset_info -> get_dataset_schema -> query_dataset -> create_chart_from_spec. Non-admin keys receive 403. This is the queue for autario-generated charts; third parties do not need it.

Input parameters:

- `limit` (number): Max datasets to return (default 25, max 200)

### `get_chart` (~207 tokens)

Get a specific chart by ID or slug. Returns a COMPACT, token-bounded summary (NOT the raw Plotly spec or full data arrays, which can be megabytes): title, insight/narration, datasets_used (with publisher), chart_type, the time/x range, and a PER-SERIES summary (first/latest/min/max/avg + point count, plus a small downsampled sample). For the full interactive chart and every data point, open view_url. The chart URL is shareable at autario.com/chart/{id}.

Input parameters:

- `chart_id` (string, required): The chart ID (numeric) or slug (hash like "nMGf-iAO") to retrieve
- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…

### `chart_instructions` (~76 tokens)

Get the Builder spec schema reference. Returns chart_type enum, required/optional fields per type, palette options, axis-override shape, annotation format, and concrete examples. Call this ONCE at session-start; the spec it returns is the input shape for create_chart_from_spec. Cheaper and clearer than guessing Plotly JSON syntax.

### `request_chart` (~609 tokens)

AUTARIO-INTERNAL (admin only). HIGH-LEVEL chart request: you do NOT build a spec, but you DO write the insight. TWO-STEP FLOW for a first-try hit: (1) PREPARE - call with dataset_id/query and NO insight; the server composes the chart deterministically and returns charted_entities (the exact entity set it drew, each with latest/peak/trough/average) + chart_type, WITHOUT publishing. IMPORTANT: a multi-country dataset is charted as an ENTITY FAMILY (the top economies, G7, the aggregate rows...), so your insight is verified ONLY against the entities actually in charted_entities | anchor every claim on one of THOSE entities and cite only THOSE per-entity values. (2) PUBLISH - call again with the same dataset_id/query PLUS your 2-3 sentence insight; the server verifies it against the real data (number-hallucination gate) and publishes, returning the URL. The server runs NO LLM of its own (you write the insight). One request = one chart. On reject it returns 422 naming WHICH number/claim failed + the charted_entities + available anchors so you fix in one step. Use THIS over create_chart_from_spec whenever you want "a good chart for this dataset/topic" without assembling a full Builder spec. Non-admin keys receive 403; third parties use create_chart_from_spec / publish_chart.

Input parameters:

- `chart_type` (string): OPTIONAL hint (line | bar | snapshot). The server still owns the final chart-type decision based on the data shape; this is a soft preference only.
- `dataset_id` (string): UUID of the dataset to chart (from search_datasets / discover_by_topic / list_chart_candidates). Preferred when you already know the dataset.
- `insight` (string): Your 2-3 sentence data insight. OMIT IT on the PREPARE call to receive charted_entities + anchors first; SEND IT on the PUBLISH call to verify + publish. Every cited number MUST be one of the per-ent…
- `query` (string): Free-form topic/search string the server resolves to the best chartable dataset (e.g. "global inflation", "US unemployment rate"). Use instead of dataset_id when you only know the topic. dataset_id w…
- `region` (string): OPTIONAL hint to focus a multi-country dataset on a region/entity (e.g. "G7", "Europe"). Soft preference; the server picks the final entity set.
- `time` (string): OPTIONAL time-range hint (e.g. "2010-2024"). Soft preference; the server uses the actual data span.

### `create_chart_from_spec` (~525 tokens)

PREFERRED chart-creation path. Send a structured Builder spec (chart_type + x_col + y_col[s] + optional group_by, palette, axis overrides, annotations) and Autario builds the chart with the same templates the Builder UI uses. Brand attribution (publisher source + autario.com) is applied automatically and cannot be overridden. Insight must cite numbers verifiable against the data | hallucinated numbers return 422 with the available anchor list. For advanced use cases the Builder cannot express, fall back to publish_chart with a freeform plotly_spec. Call chart_instructions() first if unsure of the spec shape.

Input parameters:

- `builder_spec` (object, required): Structured Builder spec. Required: chart_type + x_col + y_col/y_cols (axis charts), label_col + value_col (pie/donut), x_col + group_by + value_col (heatmap). Optional: group_by, group_values, facet_…
- `dataset_ids` (array, required): UUID array of datasets backing this chart. Autario pulls real data from these tables.
- `insight` (string): 2-3 sentence data insight using ONLY numbers from query_dataset/get_dataset_schema results. Hallucinated numbers are rejected with the available anchor list.
- `narration` (string): Longer description (optional, defaults to insight)
- `title` (string): Chart title (also settable via builder_spec.title; this top-level wins if both set). Format: "{Topic} | {Scope} ({YYYY-YYYY}, {unit})". The YYYY-YYYY year range is REQUIRED whenever the chart has a t…

### `publish_chart` (~265 tokens)

Publish a chart via freeform Plotly spec. Use create_chart_from_spec instead unless you need a Plotly feature the Builder spec doesn't cover (custom shapes, multi-axis layouts, animation frames). Requires AUTARIO_API_KEY. Brand attribution + insight verification gate apply identically to create_chart_from_spec.

Input parameters:

- `dataset_ids` (array, required): Array of dataset UUIDs that this chart uses. Autario pulls real data from these datasets to ensure no hallucinated values
- `insight` (string): 2-3 sentence data insight with specific numbers from the queried data. Must use verified numbers from query_dataset results, never from training data
- `narration` (string): Longer description of the analysis methodology and context
- `plotly_spec` (object): Plotly specification with traces array and layout object. Traces use x_col/y_col for column references and group_by/group_value for filtering (e.g. {"traces": [{"x_col": "year", "y_col": "value", "gr…
- `title` (string, required): Chart title. Include time range in parentheses, use pipe | as separator (e.g. "GDP Growth | Major Economies (2000-2024)")

### `update_chart` (~113 tokens)

Update an existing chart you own. Only the API key that created the chart can update it. Use this to modify the Plotly spec, title, or insight of a previously published chart.

Input parameters:

- `chart_id` (string, required): The chart ID or slug returned by publish_chart
- `insight` (string): Updated insight text with verified numbers
- `narration` (string): Updated analysis description
- `plotly_spec` (object, required): Updated Plotly specification with traces and layout
- `title` (string): Updated chart title

### `get_traction_overview` (~283 tokens)

ADMIN/CURATOR ONLY. Fetch the autario traction overview | ONE report uniting the three real signal sources: real human reach (GA4-humans), the MCP/agent channel (mcp_tool_call volume + success-rate + top tools), and the signup funnel (new signups, source/medium/trigger), plus the biggest drop-off in plain language, MCP-calls-per-dataset (what agents pull), top charts by views, top API endpoints (human-only), and per-app usage (web views vs MCP calls, Bubble Or Not explicit). Every page-view/funnel number is HUMAN-ONLY | own-pipeline renders (screenshot worker / chart-gen) and generic bots are classified out (`bot_or_own`, an excluded-count) and never inflate the headline. A separate `llm_crawler` section (total + by-crawler family + top pages) answers "do LLMs fetch the page content when they cite us?". 30-day window. Returns ONE JSON snapshot (cached, fast). Requires the connector to be OAuth-authorized as the autario curator account | any other caller gets a permission error. Use when asked "how is autario doing", "show traction", "what is the funnel", "which datasets do agents use", "how many signups", "do LLMs crawl us".

### `get_engine_report` (~367 tokens)

ADMIN/CURATOR ONLY. The machine-readable health of the autario data engine, in ONE snapshot: the ingestion funnel (sources registered to user-visible datasets, with every drop-off labelled by reason | policy-excluded, quarantined, errored, empty), the dirty backlog, shadow-column coverage WITH the concrete asset list still needing backfill, per-provider health, the top failure patterns, job queue state and active alerts. This is the same report /admin/health and /admin/storage render, but as data you can reason over instead of screenshots. Read-only and never auto-fixes | it tells you what is broken and which assets are affected; a human or an engine change does the fix. Set `trends: true` to add the day-bucketed run/event history, which answers "did my change help?" (the before/after gauge). Requires the connector to be OAuth-authorized as the autario curator account | any other caller gets a permission error. Use when asked "how is the engine doing", "what is broken", "why are there so many source errors", "what is the ingest funnel", "which assets need backfill", "did the last fix work".

Input parameters:

- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…
- `trend_days` (integer): How many days of history when trends=true (default 30, max 90).
- `trends` (boolean): Also return the day-bucketed engine run/event history (default false). Use it to compare before and after an engine change.

### `list_apps` (~219 tokens)

List the autario data apps (the app catalog): id, name, what each app does, its live page URL, and data_scope (private = the app works on the caller's own connected data, e.g. Search Console; public = it runs on public autario datasets only). When the caller is authenticated (API key or OAuth) each app also carries connected=true/false, whether YOUR data is already behind it (a connector instance the app consumes, or artifacts you saved in it). Start here when a user mentions an app by name ("my Audience 360", "the OKR tracker") or asks what apps exist, then call get_app_context(app_id) for the data map of one app. Read-only, no cost.

Input parameters:

- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…

### `get_app_context` (~277 tokens)

The data map behind ONE autario app, so you can query app-first instead of guessing across thousands of datasets. Returns the app manifest (what it consumes, which connector providers it reads) and, for an authenticated caller, YOUR OWN reality behind it: your connector-instance tables (per-operation table with column list, row count, backing dataset_id and last refresh), your saved artifacts in the app, and 2-3 ready-to-run query examples on existing endpoints (query the dataset_id with query_dataset or GET /datasets/:id/data). Secrets and credentials are never included. Unauthenticated callers get the public manifest view. Use when a user asks "what does my <app> run on", "what data is behind <app>", "query my Search Console data" (Audience 360), or before analyzing any app-connected data. app ids come from list_apps.

Input parameters:

- `app_id` (string, required): App id from list_apps, e.g. "audience-360", "company-compare", "okr", "builder".
- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…

### `get_my_workspace` (~223 tokens)

YOUR data-app workspace in ONE call: every autario app the calling user has activated or connected, each with its providers, connector-backed tables (dataset_id/slug + row count + last refresh), saved artifact list and a ready-to-run query example. THE first call when a user references "my <app>", "my dashboard", "my report" or asks what they have on autario | it replaces one get_app_context round-trip per app and guarantees you reason over the SAME datasets and saved views the user sees (no dataset guessing, no hallucinated numbers). Drill down with get_app_artifact(app_id, slug) for an exact saved view or query_dataset(dataset_id) for rows. Requires authentication (API key or OAuth). Read-only, no cost.

Input parameters:

- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…

### `get_app_artifact` (~252 tokens)

Load ONE saved artifact from an autario data app | the EXACT view state the user saved there (report configuration, chart spec, OKR board, screener view) plus any inline data, so your answer is grounded in what the user actually sees instead of a guess. Call after get_app_context / get_my_workspace listed the artifact slugs. Owner-gated: you see your own artifacts plus public/unlisted ones; foreign private artifacts are invisible. Very large specs/data are truncated honestly (marked with truncation notes; row/item counts stay correct) | for full raw data query the app's datasets via query_dataset. Read-only, no cost.

Input parameters:

- `app_id` (string, required): App id from list_apps, e.g. "audience-360", "okr", "builder".
- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…
- `slug` (string, required): Artifact slug from get_app_context / get_my_workspace (your_artifacts[].slug).

### `audience_360` (~565 tokens)

Audience 360 | the caller's OWN audience report over their connected Google Search Console + GA4 + social (Facebook Page, Instagram, TikTok) connector data, computed deterministically server-side (the exact numbers the user sees in the app | nothing re-derived, nothing estimated). Use this FIRST for any interpretation question about a user's traffic/audience ("why is my AI traffic falling", "which queries are rising", "which pages do AI assistants cite", "how is my funnel doing") | it is far more token-efficient and more faithful than rebuilding KPIs from raw connector tables. Pick only the sections you need: overview (funnel stages + audience segments), channels (weekly channel mix + AI-share shift + brand-vs-generic clicks), queries (top brand/generic queries + 28d risers/fallers + high-impression-low-click opportunities), content (per-page sessions x engagement joined with search demand + AI-cited pages), audience (countries, devices, new-vs-returning, totals), conversions (GA4 key events), social (connected Facebook Page / Instagram / TikTok reach, follower trends, top posts, post-format engagement + IG follower demographics), health (report-vs-API cross-checks). Lists are capped and weekly series bounded; every truncation is marked with an omitted count. Filter with range/channel/countries to sharpen the question. Requires the caller's own autario account (API key or OAuth) with the Audience 360 app connected | see get_app_context("audience-360") for the data map behind it.

Input parameters:

- `brand` (string): Optional brand term override for the brand-vs-generic query split (default: derived from the GSC property).
- `channel` (string): Optional single-channel filter (sections that cannot honor it say so in notes).
- `countries` (string): Optional comma-separated ISO country codes filter, e.g. "DEU,USA".
- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…
- `from` (string): Custom window start (YYYY-MM-DD), only with range=custom.
- `range` (string): Time window preset. Relative presets anchor at the newest data day. Default 90d. Use "custom" together with from/to.
- `sections` (array): Which report sections to return. Default ["overview","channels"]. Request only what the question needs (token efficiency); call again for more.
- `to` (string): Custom window end (YYYY-MM-DD), only with range=custom.

### `seo_360` (~637 tokens)

SEO 360 | the caller's OWN deterministic Search Console ACTION report, computed server-side from their connected GSC data (the exact numbers the user sees in the app | nothing re-derived, nothing estimated). The unit is the (query, page) pair and EVERY row ends in a concrete action, so this is the tool to call when a user asks "what should I write next", "which page should I fix first", "where am I losing clicks", "how are my rankings developing", "which pages are decaying", "how are my Core Web Vitals", "what technical SEO issues does my site have". Sections: page2_gaps (position 8-20 pairs ranked by potential click gain toward the top 3 | the core write-or-improve list), ctr_underperformers (ranks top-10 but the snippet loses the click | title/description work), orphan_demand (queries with demand whose best page is not about them | the page is missing, write it), cannibalization (one query split across pages | consolidate or differentiate), trends (click winners/losers AND position winners/losers vs the previous window, honestly flagged when the previous window is incomplete), rank_tracking (position series of the top + pinned queries with current vs 7d/28d deltas, ranking distribution Top3/4-10/11-20/21+, share-of-voice index, brand vs generic split), decay (the refresh queue: pages losing clicks across consecutive windows, ranked by lost clicks, with an optional EUR translation from the user's own click-value setting), vitals (Core Web Vitals p75 field data from the Chrome UX Report for the top pages, pass/fail per LCP/INP/CLS), audit (bounded own-site crawl snapshot: broken links, redirect chains, title/description issues, noindex/canonical conflicts, orphan pages, new-vs-fixed diff, internal-link opportunities), health (data coverage, staleness, which CTR-benchmark source applies). The CTR benchmark is the median of the caller's OWN data per position bucket, with a documented default curve as fallback per thin bucket. Deeper than audience_360 (which answers "…

Input parameters:

- `days` (integer): Analysis window in days (7-90, default 28), anchored at the newest day of the caller's data. The trend comparison uses the same-length window before it.
- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…
- `sections` (array): Which report sections to return. Default ["page2_gaps","health"]. Request only what the question needs (token efficiency); call again for more.

### `social_360` (~848 tokens)

Social 360 | the caller's OWN deterministic social performance report over their connected Facebook Page, Instagram, TikTok and YouTube data, computed server-side (the exact numbers the user sees in the app | nothing re-derived, nothing estimated). Call it when a user asks "how are my social accounts doing", "is my account growing", "which post worked best", "which format should I post more of", "when should I post", "what caused the follower jump", "how do I compare to my competitors". Sections: score (a 0-100 index per platform plus a reach-weighted blended total from engagement rate on reach, follower growth rate and posting consistency, with a trend | an index against the account's OWN history, never an industry benchmark; a component the platform cannot report is DROPPED and the weights renormalized, never counted as zero), explorer (EVERY connected channel as its own daily series for every KPI the platform officially reports | followers, new followers, posts, engagements, likes, comments, shares, views, reach | plus a per-KPI support matrix naming WHY a platform cannot answer a KPI, so a missing number is never read as a zero), posts (cross-platform top posts sortable by engagement/reach/views/likes/comments/shares/saves, the per-format benchmark inside the own account with low-sample flags, posting frequency vs engagement per week, and per-post effectiveness against the median post of the same format on the same channel), geo (the country breakdowns the platforms OFFICIALLY publish: Instagram audience demographics and the YouTube geography report; Facebook and TikTok publish none and say so), spikes (statistically unusual follower or reach days with the posts published in that window listed as CANDIDATES | hedged by design, never a claimed cause), peers (You vs the public accounts the user tracks under Settings > Competitors, via the shared daily benchmark store on Instagram Business Discovery and the YouTube Data API: follower gap, growth race, posting freq…

Input parameters:

- `days` (integer): Analysis window in days (7-90, default 28). Each platform anchors it at the newest day of ITS OWN connector table, because connectors refresh on different rhythms.
- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…
- `sections` (array): Which report sections to return. Default ["score","health"]. Request only what the question needs (token efficiency); call again for more.
- `sort` (string): How the cross-platform top-post list is ranked (posts section). Default engagement.

### `ai_visibility_360` (~576 tokens)

AI Visibility 360 | the caller's OWN brand-visibility report across the AI assistants (ChatGPT, Claude, Gemini, Perplexity, optionally Grok/DeepSeek/Mistral), read deterministically from stored runs server-side (the exact numbers the user sees in the app | nothing re-derived, NO LLM runs on this read and no run is started). Call it when a user asks "how visible is my brand in ChatGPT", "do assistants recommend us or a competitor", "which sources do the assistants cite", "what should we do to show up more", "did the AI visibility work turn into real traffic". Sections: overview (visibility score with delta and rank, the brand-vs-competitor leaderboard with visibility / share of voice / sentiment / average position, the per-provider score matrix and the concrete models that answered), prompts (per-prompt brand score vs the strongest competitor plus per-question-category rollups), sources (citation share of the brand's own domains, the cited-domain leaderboard, which providers expose citations at all), actions (the deterministic to-do queue: earned = pages to get featured on, owned = pages to build, each with impact and status), answers (the newest stored assistant answers with detected brand mentions and cited domains, text truncated honestly), impact (GA4 sessions referred by AI assistants for the property explicitly linked to this brand; an unlinked brand gets the honest empty state and the reason, never another property's numbers). A metric the window cannot support is null or absent (an honest dash), never a zero. Reads ONLY brands owned by the calling account; runs, prompt edits and settings are deliberately not exposed here. Recipe: pull the sections you need and interpret them yourself, citing the numbers. For a custom deliverable, write your derived table with create_dataset + write_rows and chart it with create_chart_from_spec. Requires the caller's own autario account (API key or OAuth) with an AI Visibility brand set up | see get_app_context("ai-visibility…

Input parameters:

- `brand` (string): Brand name or brand id. Optional when the account has exactly one brand; with several brands the tool answers with the list so you can re-call with one (nothing is picked for you).
- `days` (integer): Analysis window in days over the stored runs (1-365, default 30).
- `format` (string): Output wire format for this MCP call. Default 'toon' (Token-Oriented Notation, fewest tokens, best for tabular rows). 'compact' = minified JSON. 'json' = pretty JSON for readability. The REST API alw…
- `sections` (array): Which report sections to return. Default ["overview"]. Request only what the question needs (token efficiency); call again for more.

### `bubble_or_not` (~656 tokens)

Bubble Or Not? | Check whether a public US stock's price is running ahead of (or backed by) its fundamentals. Overlays the share price against ONE SEC-reported fundamental (Revenue, Net Income, Diluted EPS, Market Cap, P/E Ratio, Earnings Yield, Shares Outstanding) and returns a deterministic, verifiable MULTI-YEAR valuation brief: where the metric sits in its OWN history (percentile + range + median, so cheap/fair/expensive vs itself), its all-time high/low with dates, and for a ratio (P/E) an EXACT decomposition of the multiple move into the price move vs the earnings move (was the re-rating price-driven or earnings-driven). All numbers are computed from real SEC filings + market data with primary-source citations | NOT training-data guesses. Unknown tickers are fetched live (Yahoo price + SEC filings). Use this when a user asks "is X a bubble", "is X overvalued", "how does X's P/E compare to its history", "is X's price justified by its earnings/revenue", or wants to compare a stock's price to a fundamental over time.

Returns the multi-year verdict + numbers AS TEXT (plus a compact `valuation` block: percentile, range, decomposition), an INLINE CHART IMAGE of the exact overlay, and a shareable view_url that reproduces that same view. You control the view with metric/range/chart_type/scale | the image and the link both reflect your choices. When recommending the graphical view, link autario.com/apps/bubble-or-not/<ticker>.

Examples:
\- "Is NVDA a bubble?" | ticker=NVDA
\- "Apple price vs revenue, last 5 years, bars" | ticker=AAPL, metric=Revenue, range=5Y, chart_type=bar
\- "Is UNH overvalued? how does its P/E track history" | ticker=UNH, metric=P/E Ratio
\- "TSLA price vs P/E, indexed" | ticker=TSLA, metric=P/E Ratio, scale=indexed

Input parameters:

- `chart_type` (string): Optional render style for the fundamental: line or bar. Default is the app's smart choice (bars for quarterly reports, line for daily-derived metrics).
- `metric` (string): Optional fundamental to overlay against price. One of the labels from the company's available metrics (e.g. "Revenue", "Net Income", "Diluted EPS", "Market Cap", "P/E Ratio", "Earnings Yield", "Share…
- `range` (string): Optional time window for the chart. Default ALL (full history).
- `scale` (string): Optional value scale. "absolute" = raw values on a dual axis. "indexed" = both series rebased to 100 at the window start = relative performance on one shared %-axis (best for "did the price outrun th…
- `ticker` (string, required): US stock ticker symbol, e.g. AAPL, MSFT, NVDA, TSLA, AMZN

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/autario-autario-mcp/autario-mcp#diagnostics

## Score history

- 2026-10-01: 81
- 2026-09-30: 80
- 2026-09-29: 80
- 2026-09-28: 79
- 2026-09-27: 79
- 2026-09-26: 82
- 2026-09-25: 81
- 2026-09-24: 81
- 2026-09-23: 80
- 2026-09-22: 80
- 2026-09-21: 79
- 2026-09-20: 79
- 2026-09-19: 78
- 2026-09-18: 78
- 2026-09-17: 77
- 2026-09-16: 77
- 2026-09-15: 76
- 2026-09-14: 76
- 2026-09-13: 76
- 2026-09-12: 75
- 2026-09-11: 75
- 2026-09-10: 74
- 2026-09-09: 74
- 2026-09-08: 73
- 2026-09-07: 73
- 2026-09-06: 72
- 2026-09-05: 72
- 2026-09-04: 71
- 2026-09-03: 68
- 2026-09-02: 68

## Common questions

### What is the io.github.Autario/autario-mcp server?

io.github.Autario/autario-mcp is listed in the public MCP registry as io.github.Autario/autario-mcp. Query 8,000+ verified open datasets (World Bank, Eurostat, FRED, SEC) with stats and charts. This page covers its npm package (autario-mcp).

### Is the io.github.Autario/autario-mcp server safe to use?

io.github.Autario/autario-mcp scores 81 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 1 October 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the io.github.Autario/autario-mcp server expose?

io.github.Autario/autario-mcp exposes 48 tools: discover_by_topic, search_datasets, get_dataset_info, get_dataset_schema, query_dataset, and 43 more. Their descriptions and schemas cost roughly 13,320 tokens of context every time the server is loaded.

### Is the io.github.Autario/autario-mcp server still maintained?

io.github.Autario/autario-mcp is still listed as active in the MCP registry. We last reached this channel on 1 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the io.github.Autario/autario-mcp server under?

io.github.Autario/autario-mcp declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/autario-mcp
- Socket report: https://socket.dev/npm/package/autario-mcp
- Repository: https://github.com/Autario/autario-mcp
- Changelog RSS feed: https://verifymcp.io/servers/autario-autario-mcp/autario-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/autario-autario-mcp/autario-mcp.json
- HTML version of this page: https://verifymcp.io/servers/autario-autario-mcp/autario-mcp