io.github.Autario/autario-mcp

Accept open proposals by id, in bulk. Accepted entries are what overlay="with_overlay" reads; one accepted entry per target (a newer one supersedes the older). Accepting needs the owner's API key marked trusted on Account > API keys; otherwise the owner accepts on the dataset page (Proposed changes), and this tool answers with that sentence. Only call it when the user said which proposals to accept.Works on your connector tables (Meta Ads, Google Ads, Shopify, Instagram, TikTok, Google Search Console) and your uploads. Overlay rule: the vendor's source rows are never overwritten; reads default to the source, and query_dataset overlay="with_overlay" shows accepted edits merged in, each marked with its original value and provenance. Requires AUTARIO_API_KEY.

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). In one sentence: which brands ChatGPT, Claude, Gemini and Perplexity recommend when someone asks about your category. 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). EVERY number here counts only questions that do NOT name your own brand: a question naming the brand has already handed the assistant the answer. That holds for visibility, share of voice, rank and the per-assistant matrix AND for sources, gaps, pages, assistant searches, domain movers, perception and action effects. The questions that do name it are still measured, in `rankings_branded`, and the `population` block (present on every section set) carries both counts | never add the two together. The two evidence views keep every row instead: the prompt table (flag `names_you`) and `answers` (flag `question_names_your_brand`). 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").

AI Visibility 360 | manage the PROMPT LIST and the assistant selection of the caller's OWN brand, read and written through the same doors the setup page clicks (no second implementation of anything, and NO LLM runs on this path, no run is started). Call it when a user says "add these questions to my brand", "bulk import the prompts from this file", "which prompts are active", "remove the four that do not fit", "turn Gemini on for this brand". Actions: list (every prompt with id, text, topic, category, intent, branded = names your own brand, active) plus the brand's current assistant selection; add (an array of {text, topic?, category?}: the server stores each item and applies THE brand rule per item, the one promptTaxonomy holds the prompt generators to: a direct or application question that names your own brand is REFUSED with the reason, because naming yourself hands ChatGPT, Claude, Gemini or Perplexity the answer and the visibility number would then measure the question instead of the market; a direct question that names you and weighs options ("X or Y", "better than") is stored as comparison and says so in `note`; a comparison question may name brands); remove (ids: the prompt is set inactive, stays listed with its history and is never sent to an assistant again; nothing is deleted); set_assistants (the provider ids this brand runs, from the app's registry: openai, anthropic, gemini, perplexity, grok, deepseek, mistral; an unknown id answers the door's own 400 naming the valid ones, an empty array returns to the app default). `brand` is required (name or id, same resolution as ai_visibility_360). Categories: direct (category buying question, default when omitted), application (problem described, no product named), comparison (two options weighed). Roles follow the app: the owner, or a team member with the editor role, edits prompts; the assistant selection needs the admin role; a reader or a stranger gets the same refusal the app gives. Only `remove` changes something that already exists; `add` and `set_assistants` are additive or in-place on your own brand. Requires the caller's own autario account (API key or OAuth) with an AI Visibility brand set up | see ai_visibility_360 for the report these prompts feed.

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.

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

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. autario refuses to combine columns of different kinds. Read the semantics field of the schema before combining two columns. A refused call answers error_code incompatible_semantics with both columns, the reason, and the ops that WOULD work (e.g. spend and clicks do not add but divide into cpc); pass override=true with a reason to compute it anyway, and the reason is returned with the result. Every result carries a computation block naming the columns, kinds, rows and window it used. Runs on any verified autario indicator (World Bank, FRED, Eurostat, OECD, IMF, WHO, ECB, US Census, SEC).

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.

Delete all rows from a dataset you own while keeping the schema and columns intact. Useful for refreshing your own uploaded table before re-importing. Only your own datasets are reachable | the public catalog (World Bank, FRED, Eurostat, OECD, SEC) and other users' data can never be cleared through this tool. Requires AUTARIO_API_KEY.

Compare ONE indicator across MULTIPLE entities (e.g. World Bank GDP of DEU vs USA vs CHN, or a FRED / Eurostat / OECD series across countries). 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. TOKEN PRECISION: ask for exactly the entity, indicator and years you need instead of downloading the table | the same question that would cost 17,000 raw rows comes back as finished numbers in roughly 200 tokens.

Which US House members traded a stock, from their Periodic Transaction Reports (Clerk of the US House): member, date, purchase or sale, owner and official amount range, with totals of members, purchases and sales in the window. Works for companies on the autario company roster (trades are linked by the exact ticker the filer printed). Reports lag up to 45 days; Senate trades are not included.

ADMIN/CURATOR ONLY, the health of every connector autario offers. ONE row per gallery connector: provider, title, logo_url, auth_kind (oauth | key | none), access (the OAuth login state: public | testers_only | in_review | no_row; null for key connectors), pilot_accounts, review (vendor review state), users and instances connected, status, message, systemic (the repeated refusal: accounts, provider_accounts, cause, message, reports; null when none), validated_by_others (distinct non-curator accounts with a clean run) + validated_first_at, last_ok_at, last_issue_at, coverage. STATUS is one derived word, first match wins: broken_by_us (our last runs failed on our own request, the tile is hidden) > systemic_refusal (the same user-side refusal, permission or user_input, on 2+ accounts or on every account of the provider: ours to check, likely a preset asks for something these accounts do not have) > vendor_issue (open issues, mostly the vendor's fault) > needs_user_action (open issues of cause permission or user_input) > in_review / testers_only (OAuth login not public yet) > suspended (the preset declares new connections paused; instances keep refreshing) > unverified (never delivered rows) > verified. MESSAGE is the dominant open issue with cause, count, accounts and the vendor's own sentence, null when clean. Rows are sorted by status then users, so the first rows are the ones to act on. Filter with `status`. The same rows as Admin > Providers > Connector health and GET /api/admin/connector-health. Read-only. Requires the connector to be OAuth-authorized as the autario curator account | any other caller gets a permission error. Use when asked "which connectors are broken", "is the Instagram connector healthy", "what should I fix first", "which connectors wait on a vendor review".

Content 360 | the caller's OWN page-family report, computed server-side from their connected Search Console, GA4 and Bing Webmaster tables (the exact numbers the user sees in the app, nothing estimated, no LLM). Every URL of the property is matched to a PAGE FAMILY (an ordered prefix rule, by default the first path segment such as /data, /connectors, /blog; editable per property) and every day to an ISO week. Call it for "which part of my site earns impressions", "which page family brings clicks or AI referrals", "how did /blog do against the previous four weeks", "which family do LLM crawlers visit". Sections: overview (the family table of the window: impressions, clicks, CTR, impression-weighted position, GA4 sessions from Google, Bing and AI assistants by name, Bing impressions and clicks, each with the change vs the previous window of the same length; plus the weekly series per family), families (the rule in force, whether it is saved or derived, how many URLs each family takes, the top URLs with their family), signals (the operator block: LLM crawler hits by crawler family and signups by first-touch family per week; present ONLY for the site this autario runs on, otherwise an honest one-line reason). AI Overviews and AI Mode impressions are not in the Search Console API; the report says so instead of guessing. Requires the caller's own autario account (API key or OAuth) with a Search Console connection | see get_app_context("content-360").

ADMIN/CURATOR ONLY, the copy experiments (spec 2026-11-08-copy-experiments): every mail subject autario sends is an experiment with several variants held as data. Recipients are allocated by Thompson sampling on use after send (the person used their data within the window after the mail: a connector run such as Shopify or GA4, or a data read from Claude or ChatGPT over MCP; clicks only while a young experiment has no matured sends), a new variant gets a floor share while it is young, a variant clearly below half of the champion is retired and the best becomes champion, and the worker writes at most five new variants a day inside the fixed structure, each through hard gates (only facts from the fact list, every number a token, no em-dash, no superiority word, English, no near-duplicate; a failure is stored as rejected with its reason and never sent). Five actions: `list` returns every experiment with champion, rounds, sends, use rate with its 95 % interval and every variant (status, text, generation, share, use and click rates, why it was retired or rejected); `pause` stops allocation changes and generation for one experiment (the champion keeps rendering); `resume` undoes it; `retire_variant` retires one variant by hand; `add_variant` adds a variant by hand, through the same gates as a generated one. The mail kinds and their kill switches are NOT here (utils/mailPolicy). Requires the connector to be OAuth-authorized as the autario curator account | any other caller gets a permission error. Use when asked "which subject line wins", "pause the onboarding test", "add this subject as a variant".

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. Runs on any verified autario indicator (World Bank, FRED, Eurostat, OECD, IMF, WHO, ECB, US Census, SEC).

Create a data app on autario in ONE call, owned by you. You give it a name and an entry: either an https URL where the app already runs, or the app itself which autario then hosts and serves inside a locked sandbox: one HTML document (content, max 512 KB), or index.html plus the JavaScript, CSS, images, fonts and further pages it loads by relative path (files, max 50 files, 1 MB each, 2 MB in total). autario gives the app its id (the name lowercased plus a short random part, e.g. dashboard-k3x9q), so you never invent one, any name works and renaming never changes the id. The new app is PRIVATE: only you can open it, it is in no catalog and at no public URL until you call publish_app. Use this as the FIRST step whenever a user asks you to build them an app, a dashboard, a report page or a tool that runs on autario data | the public catalog (World Bank, FRED, Eurostat, OECD, WHO, IMF, ECB, US Census, SEC) or the user's own connector tables (Google Search Console, GA4, Google Ads, Meta Ads, YouTube, TikTok, Instagram, Facebook, Shopify, LinkedIn). Inside the HTML read data with autario.js, never with fetch (the sandbox has no network): autario.ready(), autario.datasets(), autario.query(datasetId, {limit, orderBy, where}), autario.artifacts.get/set(key), autario.rows.insert/select/update/delete(key, ...) on datasets the app declares in datasets_owned (contacts of a CRM, notes of each viewer); ready() gives user.role and an anonymous user.id per app, never the email of the viewer; autario inlines the SDK into every app, docs at https://autario.com/developer/docs/autario-js. Pass `datasets` with the ids of the user's own tables the app may read. Follow it with write_app_artifact (to save the app's data or saved views), get_app_preview_url (to hand the user a link to try) and publish_app (to make it public). Requires authentication.

PREFERRED chart-creation path, for any autario dataset (World Bank, FRED, Eurostat, OECD, SEC, or your own upload / connector table). Send a structured Builder spec (chart_type + x_col + y_col[s] + optional group_by, palette, axis overrides, annotations) and Autario renders the Plotly 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.

Create a new empty dataset on Autario, alongside the public catalog (World Bank, FRED, Eurostat, OECD, SEC) but private to you unless you set is_public. Returns a dataset_id you can populate with write_rows, then query with query_dataset and chart with create_chart_from_spec. SEARCH FIRST: only create a dataset if search_datasets / list_indicators shows the data does not already exist on Autario. Requires AUTARIO_API_KEY.

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. Works on public indicators (World Bank, FRED, Eurostat, OECD) and on your own connected series (Google Search Console, GA4, Meta Ads, Shopify); omit entity for an entity-less private KPI series. 2-15 candidates.

Delete an app YOU own, for good: its code (every uploaded file), its manifest, its saved artifacts, what each viewer saved in it (per-viewer state and images), its share links, team roles on it and its review history all go in one step, and a published app leaves the app store and its URLs stop working at once. Your datasets are NOT touched: connector data from Shopify, GA4 or Instagram and any World Bank or FRED table stay as they are. There is no undo and no archive, so pass confirm: true only after the user said to delete this app by name; to just take it off the store use unpublish_app instead. First-party autario apps and apps you do not own answer not found.

Permanently delete a dataset you own, and all its data. This action cannot be undone. Only the dataset owner can delete it | the public catalog (World Bank, FRED, Eurostat, OECD, SEC) is a permanent URL contract and is not deletable through this tool. Requires AUTARIO_API_KEY.

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). Runs on any verified autario indicator (World Bank, FRED, Eurostat, OECD, IMF, WHO, ECB, US Census, SEC).

Discover the most relevant verified datasets for a given topic, across the public autario catalog (World Bank, FRED, Eurostat, OECD, IMF, WHO, ECB, US Census, SEC). 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. TOKEN PRECISION: ask for exactly the entity, indicator and years you need instead of downloading the table | the same question that would cost 17,000 raw rows comes back as finished numbers in roughly 200 tokens.

Rank candidate drivers of a KPI one at a time: given a target indicator + multiple candidates, order them 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. Use decompose_drivers instead when the candidates may overlap. Runs on any verified autario indicator (World Bank, FRED, Eurostat, OECD, IMF, WHO, ECB, US Census, SEC).

ADMIN/CURATOR ONLY, the GEO/SEO experiment ledger (spec 2026-11-08-geo-mcp-loop): the dated book of every crawler-touchable change, marker, open question and prediction, the one thing that makes a move in the organic channel (Google, Bing, LLM citations) attributable. Three actions: `add` writes one row ({title, change?, expected_effect?, kind? = change | marker | open_question | prediction, date? = today, review_after_days? = 14, notes?, url_path? = the page the change touched, as a path like /connectors/shopify, so the row joins the per-URL signals}; same date + title twice = reported as duplicate, never a second row); `review` records the verdict on one row ({id, verdict = helped | hurt | neutral | unknown, notes?}); `list` returns the ledger ({open?: true = unreviewed rows only, limit? = 50}), each row with id, date, kind, title, change, expected_effect, review_after_days, reviewed_at, verdict, notes, url_path. The numbers to judge a row against are in get_traction_overview under `geo` (28 days of geo_metrics_daily, SSR health, the crawler split) and `geo_ledger` (open rows with due flags, the last verdicts, Bing citations per URL); per-URL detail is in seo_360 / content_360 / audience_360 on the autario.com property. The same doors as the CLI `geo-experiment add|review|list`. Requires the connector to be OAuth-authorized as the autario curator account | any other caller gets a permission error. Use when asked "log this change in the GEO ledger", "what is due for review", "record the verdict on experiment 12".

Load ONE saved artifact from an autario data app | the EXACT view state the user saved there (a saved SEO 360 / Audience 360 / Social 360 / AI Visibility 360 report configuration, a Plotly chart spec, a 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.

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 | Google Search Console, GA4, Google Ads, Meta Ads, YouTube, TikTok, Instagram, Facebook, Shopify, LinkedIn, Bing) 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.

The link to OPEN an app you own, plus where it stands. Returns preview_url (a private, never-indexed page where only you can run the app, reading World Bank, FRED, Eurostat or your own connector data through the sandbox bridge), public_url (null while the app is private, the shareable link once you publish), app_url (the app alone on the whole screen with its own web manifest: the link to open on a phone and add to the home screen, like an installed app; for others it opens once the app is published), its visibility, whether it is indexed, and next_step: one sentence naming the next call to make. Use it to hand a user something to click after create_app, and to check what is still missing before publish_app.

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}.

Get a company's fundamentals and price history over time, POINT-IN-TIME correct, for backtests and trend questions. Each SEC figure (revenue, net income, cash flow, balance sheet, EPS, dividends) appears from the day it was first filed, never from its period end, so a backtest never sees a number before the market did. Flows are trailing-12-month as known on each day; per-share values are on today's split basis like adj_close. Same data as GET /api/v1/public/stocks/{ticker}/history (CSV there with format=csv). Cite citation_url. Fields: close, adj_close, open, high, low, volume, revenue, gross_profit, research_and_development, sga, operating_income, interest_expense, income_tax, net_income, operating_cash_flow, capital_expenditure, depreciation_amortization, total_assets, total_liabilities, stockholders_equity, cash_and_equivalents, long_term_debt, shares_outstanding, eps_diluted, dividends_per_share, market_cap, pe_ratio, price_to_book, price_to_sales, dividend_yield. Examples: - "How did Apple's P/E move over the last 5 years?" | ticker=AAPL, metrics=["pe_ratio","eps_diluted"], window="5y" - "MSFT revenue and free cash flow inputs since 2015, quarterly" | ticker=MSFT, metrics=["revenue","operating_cash_flow","capital_expenditure"], window="2015-01-01:", interval="quarterly"

Get current stock metrics for a public company, from live market data joined with its SEC filings. 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). Price metrics: price, open, high, low, volume, perf_1d, perf_1w, perf_1m, perf_3m, perf_1y, perf_ytd, latest_date. perf_1d..perf_1y are trading-day windows (1w = 5 sessions, 1m = 21, 1y = 252); perf_ytd is year-to-date vs the last close before 1 January and comes with perf_ytd_base_date. Fundamental metrics (covered US companies, from SEC filings, each with period, formula and source): revenue, gross-profit, operating-income, net-income, net-margin, diluted-eps, dividends-per-share, operating-cash-flow, free-cash-flow, ebitda, total-assets, stockholders-equity, long-term-debt, gross-margin, operating-margin, roe, roa, debt-to-equity, payout-ratio, revenue-growth-1y/3y/5y, eps-growth-1y/3y/5y, market-cap, pe-ratio, price-to-book, price-to-sales, ev-to-ebitda, fcf-yield, dividend-yield, or fundamentals for all of them. For a history over time use get_company_fundamentals. Examples: - "What is INTC trading at?" | ticker=INTC, metrics=["price", "perf_1d"] - "How did NVDA do this year?" | ticker=NVDA, metrics=["perf_ytd", "price"] - "What is Apple's return on equity and P/B?" | ticker=AAPL, metrics=["roe", "price-to-book"]

Explain the state of ONE connected platform (Search Console, Shopify, an ads account, an AI usage bill): is its data fresh, which reports arrived, which came back empty because the account has no such data, which did not arrive and why, and who has to act. Returns the connector plus `health`: state (ok | stale | needs_sign_in | reports_missing | retrying | ours | never_ran | running), sentence, last_run_at, last_success_at, schedule, next_run_at, data_as_of per dataset (basis data_day = newest day in the table, last_pulled = when it was fetched), reports[] { report, name, outcome: delivered | empty | not_fetched, rows, sentence } and next_step { who: assistant | user | nobody, action, url? }. Use it when list_connectors shows a state other than ok and the user wants to know what is wrong, or before telling the user to sign in again. Read-only: it never starts a run and never changes the configuration. Requires AUTARIO_API_KEY.

Get full metadata for a specific dataset including title, description, publisher (World Bank, FRED, Eurostat, OECD, WHO, IMF, ECB, US Census, SEC, or your own connector), 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. On one of YOUR private or derived tables (a connector report, an upload, marketing_daily, an app result) it also carries `lineage`: `upstream` = where the table comes from (connector + report, upload, app result, the tables a derived one folds) and `downstream` = what reads it (derived tables, apps, charts, project KPIs, its share), each node with kind, label and the autario page. A table shared with you shows only the kind of each source.

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. The `semantics` block says what each column MEANS in one sentence (kind, definition, unit, currency, time grain, and where the meaning came from: the metric registry, the column name, the asset, or honestly none). autario refuses to combine columns of different kinds. Read the semantics field of the schema before combining two columns.

ADMIN/CURATOR ONLY, autario's own ingest engine. The machine-readable health of the pipeline that pulls World Bank, FRED, Eurostat, OECD, WHO, IMF, ECB, US Census and SEC into the catalog, 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".

Fetch data for ONE entity across MULTIPLE indicators, joined automatically on time via shadow columns, even when the indicators come from different publishers (World Bank GDP next to FRED unemployment next to Eurostat energy). 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. TOKEN PRECISION: ask for exactly the entity, indicator and years you need instead of downloading the table | the same question that would cost 17,000 raw rows comes back as finished numbers in roughly 200 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).

Get every position one investor reported on SEC Form 13F for a quarter: CUSIP, issuer, class, value in USD, shares, weight in the reported portfolio, change in shares against the prior quarter, new and closed flags, and the roster ticker where the issuer is a company autario covers. Defaults to the latest quarter; quarters_available lists the rest. Form 13F covers long US-listed equities and options only (no shorts, no cash) and is filed up to 45 days after quarter end. Example: investor="berkshire-hathaway", quarter="2026-Q2".

YOUR data-app workspace in ONE call: every autario app the calling user built, activated or connected, each with its platforms (Google Search Console, GA4, Google Ads, Meta Ads, YouTube, TikTok, Instagram, Facebook, Shopify, LinkedIn, Bing), connector-backed tables (dataset_id/slug + row count + last refresh), saved artifact list and a ready-to-run query example, plus shared_with_you: tables another account shared with you read-only (dataset_id, title, shared_by). 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.

Get the stock trades one US House member reported on Periodic Transaction Reports (published by the Clerk of the US House): transaction date, notification date, filing date, owner (self, spouse, joint, dependent child), asset as printed, ticker when the filer printed one, purchase or sale, and the official amount range (lower and upper bound; the law asks for a range, not an amount). Reports lag the trade by up to 45 days. Every row links the source PDF. Example: politician="Josh Gottheimer", window="1y".

ADMIN/CURATOR ONLY, autario's own traction. 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), the signup funnel (new signups, source/medium/trigger) and the activation half of it (charts created, charts published, publish failures, logins), the BUYER funnel `revenue_funnel` (outreach, clicks, signups, uses, buys per channel, program = utm_campaign and claim variant = utm_content, rates between the stages, the prior period of the same length, detail stages use_connector / use_mcp / use_api / use_app / use_export / return_w2 under `detail`, and `mail_programs` = sent, clicked, used, bought per A/B variant of every mail with two copies; `experiments` = every copy experiment with champion, rounds, sends, use rate and its 95 % interval, variant by variant; the same numbers as the curator's funnel_daily dataset), 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", "how do the claim variants A and B convert", "which datasets do agents use", "how many signups", "do LLMs crawl us".

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?". Runs on any verified autario indicator (World Bank, FRED, Eurostat, OECD, IMF, WHO, ECB, US Census, SEC).

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 from Google Search Console, GA4, Meta Ads, Google Ads, YouTube, TikTok, Instagram, Facebook, Shopify or LinkedIn; public = it runs on public autario datasets only). Includes AI Visibility 360 (which brands ChatGPT, Claude, Gemini and Perplexity recommend), SEO 360, Social 360, Audience 360 and Bubble Or Not. 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", "my projects") or asks what apps exist, then call get_app_context(app_id) for the data map of one app. Read-only, no cost.

AUTARIO-INTERNAL chart queue (admin only): list catalog datasets (World Bank, FRED, Eurostat, OECD, WHO, IMF, SEC) 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.

List published chart visualizations on Autario, built on the public catalog (World Bank, FRED, Eurostat, OECD, WHO, IMF, SEC) and rendered with Plotly. Returns chart IDs, titles, insights, linked datasets, and creation dates. Use to discover existing analyses before building a new one, and to find a shareable autario.com/chart/{id} link for an answer.

List the platform connectors set up on this Autario account: search, web and product analytics, ads, social, commerce, payments, AI usage and developer platforms. The answer names each connected platform, so call this instead of guessing which ones exist. Each entry carries its live dataset_id (queryable via query_dataset), datasets[] (ALL datasets the connector materialized | multi-report connectors produce one per report), refresh interval, last refresh time, and `health`: state (ok | stale | needs_sign_in | reports_missing | retrying | ours | never_ran | running), how old the data is per dataset, and next_step { who: assistant | user | nobody, action, url? }. CHECK health.state BEFORE answering from a connector table: ok = use it; stale = call refresh_connector once; needs_sign_in = give the user the one sign-in link in next_step.url, do not refresh; reports_missing = say which reports and why (get_connector_status has the per-report sentences); retrying or ours = answer from the data you have and say how old it is. Use this whenever a user asks about "my Search Console data", "my ad spend", "my store orders" or wants a cross-platform weekly report. Connectors are created and configured by the account owner in the Autario UI (autario.com/manage) | this tool only reads them, it never changes settings or handles credentials. Requires AUTARIO_API_KEY.

Browse the Autario indicator registry, the semantic layer over the whole public catalog (World Bank, FRED, Eurostat, OECD, WHO, IMF, ECB, US Census, SEC). Each indicator has a topic (economy, health, energy, …), unit (USD, %, years, …), frequency (year/month/day), and entity_type (country/subnational/aggregate), and can be filtered by publisher. Use this to discover what data is available before querying it, and to get the indicator IDs that get_entity_data, compare_entities and every stats tool take. Much more precise than search_datasets when you know what topic, publisher or unit you need.

List the well-known investors whose SEC Form 13F portfolios autario tracks (Berkshire Hathaway, Bridgewater, Pershing Square, Scion, Renaissance, ARK and more), with the latest reported quarter end, total reported value, number of positions and largest holding. Use it to find the slug get_investor_portfolio takes. Form 13F is filed up to 45 days after the quarter ends, so positions are as of the quarter end, not today.

List the overlay layer of a dataset you can read: the ACCEPTED derived columns, flags, corrections and mappings (default), each with before/after, reason, who and when. The owner may also ask for state "rejected", "superseded" or "all". To read the rows with the overlay merged in, use query_dataset with overlay="with_overlay". Works on your connector tables (Meta Ads, Google Ads, Shopify, Instagram, TikTok, Google Search Console) and your uploads. Overlay rule: the vendor's source rows are never overwritten; reads default to the source, and query_dataset overlay="with_overlay" shows accepted edits merged in, each marked with its original value and provenance. Requires AUTARIO_API_KEY.

List the members of the US House of Representatives who filed Periodic Transaction Reports (STOCK Act stock trade disclosures published by the Clerk of the US House), with their number of reported trades, purchases, sales, most traded asset and latest report date. Use it to find the slug get_politician_trades takes (first-last-state, e.g. josh-gottheimer-nj). Senate trades are not included.

List the open proposals on one of your datasets (derived columns, flags, corrections, mappings), newest first, each with kind, column, before (original) and after (value), reason, who wrote it (person, api_key, agent) and when, plus the count per state. Owner only. Works on your connector tables (Meta Ads, Google Ads, Shopify, Instagram, TikTok, Google Search Console) and your uploads. Overlay rule: the vendor's source rows are never overwritten; reads default to the source, and query_dataset overlay="with_overlay" shows accepted edits merged in, each marked with its original value and provenance. Requires AUTARIO_API_KEY.

Marketing Report | the caller's OWN brand marketing report, read deterministically from the derived `marketing_daily` table server-side (the exact numbers the user sees in the app | nothing re-derived, nothing estimated, no LLM). In one sentence: what one brand spent across Meta Ads, Google Ads, TikTok Ads, Shopify, Amazon and Google Analytics, and what came back, under ONE definition of return on ad spend. Call it when a user asks "how did brand X do last week", "what did we spend on Meta vs Google", "which campaign has the best ROAS", "what is our cost per acquisition this month", "did spend go up compared to last week", "is any channel stale". Sections: overview (spend, conversions, revenue, conversion value, return on ad spend and cost per acquisition for the period, each with the same figure for the comparison period and the move between them, plus one real total PER CURRENCY and the printed definition of every ratio), channels (one row per channel | meta_ads, google_ads, tiktok_ads, shopify, amazon, ga4 | with the same columns, its share of the spend and its own move), campaigns (top campaigns by spend and by return on ad spend, each carrying the spend behind the ratio so a tiny campaign with a spectacular number is visibly tiny), daily (one row per day that actually reported, with spend and return on ad spend). THE HONESTY RULES, which are part of the data and not a disclaimer: money is NEVER converted between currencies, so a total over more than one currency is null with a `reason` naming them and the per-currency breakdown is the answer instead; conversions and conversion value are what each ad platform reported under its OWN attribution setting and are never de-duplicated across channels; shop revenue and analytics revenue are separate rows and must never be added; a day no platform reported is ABSENT from the daily series rather than present as a zero; a ratio with no denominator is null, never infinite and never zero. The comparison period is the same window shifted by its own rhythm (a week for the week presets, so Monday compares to Monday). Scope: one brand per call | pass `brand` to pick one (the older spelling `client` is still accepted), otherwise the brand selected in the autario app answers, and with none selected the account's Default brand. A brand that is not the caller's answers an error, never another brand's numbers. An account with nothing connected gets a named empty state saying which of the four reasons applies, never a zero. Requires the caller's own autario account (API key or OAuth) with at least one ad or shop connector | see get_app_context("marketing-report").

ADMIN/CURATOR ONLY, the outreach engine's prospects (people who are NOT accounts, mailed a paced 3-step sequence from hello@mail.autario.com; spec 2026-11-08-outreach-engine). The prospects are the agencies and merchants of the PMF test (the people who run Shopify, Meta Ads and GA4 for clients), never autario accounts. Four actions: `add` inserts rows for a campaign key ({email, country, segment, source_url, name?, company?, variant?}, max 500 per call): addresses are lower-cased, the domain derived, the claim variant A/B assigned round-robin per segment when missing, utm fields stamped (utm_source=outreach, utm_medium=email, utm_campaign=<key>, utm_content=<variant>), and every row that fails eligibility right now is reported back with its reason (country_not_allowed outside US/GB/CA/AU by default, opted_out, domain_suppressed, is_account, duplicate) instead of sitting in the table; `list` returns prospects filtered by campaign and status; `stats` returns per campaign and variant the counts by status, sends per step, opened, clicked and signups (prospects whose address became an account), today's sends, the daily cap and ramp day, and whether the sending domain is verified; `mark` sets one prospect to replied or blocked by hand (reply detection is manual); `history` returns ONE prospect (by prospect_id or email) with every mail sent to it, the provider events per mail (delivered, opened, clicked with the link, bounced, complained), first delivered/opened/clicked per mail and the signup date when the address became an account. `list` also filters by segment, country, variant and a free-text q, and every row carries delivered_at, opened_at, clicked_at, clicks and signed_up_at. `start` releases the next batch of a campaign: `batch_size` waiting prospects per variant (default 300), and it needs `confirm_count` = the planned release (a call without it, or with a stale number, answers the planned count per variant and releases nothing), the same door as the Start button on the Sequence tab; a release only gives mail 1 a due date, the worker sends it paced under the daily cap and only while OUTREACH_MAIL is on (refused while the switch is off, without a postal address or with an unverified sending domain); calling it again on a running campaign releases the next batch. The same doors as /api/admin/outreach. Requires the connector to be OAuth-authorized as the autario curator account | any other caller gets a permission error. Use when asked "add these prospects", "how is the outreach going", "mark this one as replied", "release the next 300".

Period-over-period percentage change for an indicator. Use for growth rates (YoY, QoQ, MoM) | "how fast did German GDP grow", "what is US CPI doing month over month". Runs on any verified autario indicator (World Bank, FRED, Eurostat, OECD, IMF, WHO, ECB, US Census, SEC).

Projects | the caller's OWN project board with its objectives and key results, read and written deterministically (no LLM on this path): what a team agreed to achieve, what it works on, who works on it, how far along it is, and which key result each piece of work pays into. Call it for "what is my team working on", "which key result has no project behind it", "what does marketing contribute", "which projects are off track", "what is undecided", or to add or move a project, objective or key result. PROJECTS: "list" folds the board on ONE axis, `group` = okr (default) | country | function | person. On person a project appears under its owner and every contributor; on the other axes once. Nothing set on the axis lands in a NAMED group ("No country set"), never dropped. Undecided projects come back in `inbox`. "get" returns one project with milestones and KPIs; "create" adds one; "update" changes one (stage, progress, traffic light, dates, parent, budget, effort, impact, key_result_id). A project carries a target date (due sentence derived on read), a parent (three levels at most), prerequisites (`blocked_by`), a budget in its own currency (never converted), effort in days and impact 1 to 5; `sort` = effort_impact orders by impact then effort without a score. OBJECTIVES: "objectives" returns every objective with its key results: value, `source` (dataset or manual), a DERIVED status (on track, at risk, off track, no data yet; from baseline, target, direction and time left, never set by hand, and no value is never on track), guardrails, target history and the projects behind it. "create_objective" needs `title`; "update_objective" needs `id`; "create_key_result" needs `objective_id`, `title`, `target` (or `country_values`); "update_key_result" needs `id`. Changing a target needs `target_reason` (ten characters or more) and is kept in a history nothing rewrites. A key result may carry values per country (`country_values`) and says how they add up (`aggregation`); with country values its target and current are DERIVED from them (sum, average, or none = no total, `country_total` says how many countries reported) and a typed target is ignored, and with `country_column` a dataset-bound key result reads `value_column` once per country. A key result with `guards_id` is a GUARDRAIL: breached, the guarded key result is off track even at full attainment. THE VALUE RULE for KPIs and key results: EITHER a typed number OR read live from a column of any dataset on this account, such as a Google Search Console, Shopify or World Bank table or an uploaded CSV (dataset_id + value_column, optionally filter_column + filter_value), never both. A value that cannot be read is null with a `reason`, never zero. NEVER: it never derives the traffic light or progress of a project (a person sets both), never invents a key result (link one of the account key results by `key_result_id`; `list` returns them as `key_results`), and never reaches another account: a foreign id answers not found. On a shared board a member with the editor role is a project lead: the board admin decides which fields a lead may change, and a refused field answers 403 naming it. Requires the caller's own autario account (API key or OAuth).

Propose a DERIVED column on one of your datasets: a value per row such as a topic, a group, a label, a campaign or a cleaned category. Use it to label or group posts, orders or campaigns. The source rows are never changed: the column lives in the overlay layer next to them, with your reason and who wrote it. Get each row's `_row_key` from query_dataset with overlay="with_overlay". The owner accepts or rejects the proposal (dataset page, Proposed changes, or accept_proposals); until then it counts nowhere. Returns the proposal ids. Works on your connector tables (Meta Ads, Google Ads, Shopify, Instagram, TikTok, Google Search Console) and your uploads. Overlay rule: the vendor's source rows are never overwritten; reads default to the source, and query_dataset overlay="with_overlay" shows accepted edits merged in, each marked with its original value and provenance. Requires AUTARIO_API_KEY.

Propose corrections of single cells of one of your datasets, each with a reason. The original value stays in the source and is shown next to the correction; if the provider later delivers a different value, the correction stops applying (stale) instead of hiding the provider's revision. Returns the proposal ids. Works on your connector tables (Meta Ads, Google Ads, Shopify, Instagram, TikTok, Google Search Console) and your uploads. Overlay rule: the vendor's source rows are never overwritten; reads default to the source, and query_dataset overlay="with_overlay" shows accepted edits merged in, each marked with its original value and provenance. Requires AUTARIO_API_KEY.

Flag rows (or single cells) of one of your datasets that look wrong, each with the reason ("negative spend", "duplicate of another row", "currency differs from the account"). A flag changes no value; it marks the row for the owner and shows next to it in every overlay view. Use it when you find inconsistencies you should not fix yourself. Returns the proposal ids. Works on your connector tables (Meta Ads, Google Ads, Shopify, Instagram, TikTok, Google Search Console) and your uploads. Overlay rule: the vendor's source rows are never overwritten; reads default to the source, and query_dataset overlay="with_overlay" shows accepted edits merged in, each marked with its original value and provenance. Requires AUTARIO_API_KEY.

Master data: propose that several source values of one column mean the same thing, as source value -> canonical value with a reason (campaign names spelled differently, SKUs across shops, channel spellings like "FB" and "facebook" -> "Facebook"). Once accepted, every overlay read shows the canonical value in place of the source value (the source value stays as the original), so grouping by that column groups them together. Per dataset and column. Returns the proposal ids. Works on your connector tables (Meta Ads, Google Ads, Shopify, Instagram, TikTok, Google Search Console) and your uploads. Overlay rule: the vendor's source rows are never overwritten; reads default to the source, and query_dataset overlay="with_overlay" shows accepted edits merged in, each marked with its original value and provenance. Requires AUTARIO_API_KEY.

Publish an app YOU own, on a paid plan: on Free an app stays private and this answers 402 plan_required with the upgrade link. Two ways to publish: "public" gives it a tile in the autario app store on its own shelf (social next to Social 360, public data next to the World Bank and FRED data surfaces), credited to you, plus a public URL, "unlisted" gives it only the URL, so anyone you send the link to can open it and nobody else finds it. Every publish runs a content check first and refuses, naming the rule and the line, an external script, an embedded frame, a form posting elsewhere, a redirect, an advertising or affiliate link, hidden text, or text aimed at AI agents in the name, tagline or manifest. Both unlisted and public then pass ONE AI content review per content version (text and code), synchronously, and both need a shelf first (create_app or update_app_manifest with shelf, else 422 shelf_required with the allowed ids), a public listing needs the app hosted on autario (upload_app_bundle): a block returns the reasons (edit the app and publish again), review_unavailable means try again later. Returns public_url. Viewers read data through autario.js with their own role: a stranger sees public catalog data only, a team member the owner invited to the app (Account > Team) sees the datasets the app declares. Note that a published app is deliberately NOT search-engine indexed; only autario can put a community app into the sitemap. Use it when the user says the app is ready to share. unpublish_app reverses it and is never refused.

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.

Query the rows of ONE dataset | a public table from World Bank, FRED, Eurostat, OECD, WHO, IMF, ECB, US Census or SEC, or one of your own uploads / connector tables (Google Search Console, GA4, Meta Ads, Shopify), or a table another account shared with you (read-only, listed by get_my_workspace under shared_with_you) | with optional filtering, sorting, and field selection. Supports server-side aggregations (avg/sum/count/min/max/stddev/median) with optional GROUP BY. All aggregates are numerically correct even though values are stored as text (no lexicographic min/max). TOKEN PRECISION: ask for exactly the entity, indicator and years you need instead of downloading the table | the same question that would cost 17,000 raw rows comes back as finished numbers in roughly 200 tokens. 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). Reach for get_entity_data instead when you want ONE entity across SEVERAL indicators joined on time. Always cite autario.com as the data source. autario refuses to combine columns of different kinds. Read the semantics field of the schema before combining two columns. Call get_dataset_schema first and read its `semantics` block: it names the kind of every column, so you never add a click count to an impression count.

Pull the latest numbers from one connected platform right now and refresh its hosted Postgres table on Autario. Works for whatever that connector is for, whether it is Search Console, Shopify, an ads account or an AI usage bill. Use when health.state is stale or never_ran, or the user says "get the latest". The answer is the finished run: status (refreshed | failed), rows, dataset_id and `health` with one outcome per report (delivered | empty | not_fetched, with the sentence why) and next_step. An empty report is not an error: the account has no such data. It does NOT start a run that cannot help and says why instead: needs_sign_in (the login is gone, give the user next_step.url), already_running, or too_soon (one run per connector per 10 minutes; retry_at says when). Call it ONCE per question, never in a loop. It cannot change settings, reports, schedule or the login. Get the connector_id from list_connectors. Deterministic fetch, no LLM cost. Requires AUTARIO_API_KEY.

Linear regression of y ~ x for one entity. Returns slope, intercept, R² and interpretation. Use for "how does X predict Y?" questions. Runs on any verified autario indicator (World Bank, FRED, Eurostat, OECD, IMF, WHO, ECB, US Census, SEC).

Reject open proposals by id, in bulk. A rejected entry stays in the history (list_overlays state "rejected") and never counts. Use it to withdraw your own proposals or when the user says which to reject.Works on your connector tables (Meta Ads, Google Ads, Shopify, Instagram, TikTok, Google Search Console) and your uploads. Overlay rule: the vendor's source rows are never overwritten; reads default to the source, and query_dataset overlay="with_overlay" shows accepted edits merged in, each marked with its original value and provenance. Requires AUTARIO_API_KEY.

Remove ONE overlay entry (a derived value, flag, correction or mapping) by id. Only the overlay entry goes; the source rows are never touched. Removing an ACCEPTED entry needs the owner in the browser or a trusted API key; the owner can always remove a proposal.Works on your connector tables (Meta Ads, Google Ads, Shopify, Instagram, TikTok, Google Search Console) and your uploads. Overlay rule: the vendor's source rows are never overwritten; reads default to the source, and query_dataset overlay="with_overlay" shows accepted edits merged in, each marked with its original value and provenance. Requires AUTARIO_API_KEY.

Report a data-quality problem you found in an autario dataset or chart (World Bank, FRED, Eurostat, OECD, WHO, IMF, ECB, US Census, SEC or any other publisher in the catalog), 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 unresolved issue again never creates a duplicate row: it is COUNTED on the existing finding (`occurrences` in the response), and once the same issue has been reported three times it is escalated into the human review queue. So a repeat is safe, but it is not silent | only report again if you observed the problem again. Requires authentication.

AUTARIO-INTERNAL high-level chart request (admin only): the server builds the Plotly chart from a catalog dataset (World Bank, FRED, Eurostat, OECD, WHO, IMF, SEC), 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.

Rolling window statistics (mean/std/min/max/sum) for an indicator. Smooths noise, reveals trends | use it before claiming a turning point in a monthly FRED or Eurostat series. Runs on any verified autario indicator (World Bank, FRED, Eurostat, OECD, IMF, WHO, ECB, US Census, SEC).

Screen and rank the covered US companies (and the other stocks with a daily price series) by fundamentals and price technicals, from daily snapshots built on SEC filings and adjusted daily closes. Use this for questions like "fastest growing companies", "most profitable", "cheapest by earnings yield", "stocks below their 200-week moving average", "near a 52-week low", or to pull a screen for a backtest (as_of = a past day). A company without every input of the screen is not listed (never ranked as zero). Every row links its company page and source datasets. Presets: growth (mean percentile of 1-year revenue and EPS growth), profitability (net margin), value (earnings yield), near-52-week-high, near-52-week-low, below-200-week-ma. most-held-by-13f (how many tracked investors list the company on their latest Form 13F). Planned, not answerable yet: dividend, insider-buying. Filter and sort columns: revenue_growth_1y, eps_growth_1y, net_margin, growth_score, earnings_yield, pct_from_52w_high, pct_from_52w_low, pct_vs_200w_ma (percent), holders_13f (count). Examples: - "Fastest growing companies?" | preset="growth", limit=10 - "Profitable stocks below their 200-week MA" | filters={"net_margin":{"min":10},"pct_vs_200w_ma":{"max":0}}, sort="pct_vs_200w_ma"

Search the Autario data catalog by keyword | thousands of normalized public datasets from World Bank, FRED, Eurostat, OECD, WHO, IMF, ECB, US Census and SEC, plus your own uploads and connector tables (Google Search Console, GA4, Meta Ads, Google Ads, YouTube, TikTok, Instagram, Facebook, Shopify, LinkedIn, Bing). 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. TOKEN PRECISION: ask for exactly the entity, indicator and years you need instead of downloading the table | the same question that would cost 17,000 raw rows comes back as finished numbers in roughly 200 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. Runs on any verified autario indicator (World Bank, FRED, Eurostat, OECD, IMF, WHO, ECB, US Census, SEC).

SEO 360 | the caller's OWN deterministic Google 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 "who comes from where"): this one prescribes the next SEO action. Requires the caller's own autario account (API key or OAuth) with a Search Console connection | see get_app_context("seo-360").

Social 360 | the caller's OWN deterministic social performance report over their connected Facebook Page, Instagram, TikTok, YouTube, LinkedIn and Threads data, computed server-side (the numbers the user sees in the app, nothing estimated). Call it for "how are my social accounts doing", "which post worked best", "which format should I post more of", "what caused the follower jump", "how much of this came from ads", "how do I compare to my competitors". Sections: score (a 0-100 index per platform plus a reach-weighted blend from engagement rate on reach, follower growth and posting consistency, against the account OWN history; a part the platform cannot report is dropped, never zero), explorer (every channel as daily series for every KPI its platform reports, a support matrix naming WHY a KPI is missing, per channel the window sums of paid reach and paid engagements from Meta Ads, and the Instagram splits: views by content type incl. its Ads type, views and reach by followers vs non-followers, interactions by content type, story replies, reposts, contact button taps), posts (top posts sortable by engagement, reach, views, likes, comments, shares, saves and the rates on reach; format benchmark; frequency vs engagement; effectiveness vs the median post of the same format; Instagram posts with reposts, follows, profile visits and reel skip rate; stories as format STORY rows with replies, profile actions, link taps and navigation; every post and story row carries its type (post, reel, video, carousel, image, text, link, story) and not_reported names, per platform and type, the metrics the platform reported for no row of that type; PAID VS ORGANIC: a post a Meta ad promotes carries paid=true, paidReach, paidInteractions and the campaign next to its organic numbers, a post no ad names is organic by fact), geo (official country breakdowns: Instagram demographics, YouTube geography; plus follower age, gender and top cities), spikes (unusual follower or reach days with the posts of that window as CANDIDATES, never a claimed cause), peers (You vs tracked public accounts: follower gap, growth race, posting frequency, public engagement), findings (deterministic works / needs-attention list, each with a hedged reading and an evidence line), financials (SOCIAL ads only: Meta, TikTok, Pinterest, Snapchat, Reddit, LinkedIn Ads, with Google Ads in marketing_report; spend, CPC, CPM per account and campaign, the currency on every figure, revenue and ROAS only where the platform reports a money value, paid vs organic side by side, never summed), health (what each platform counts as reach, freshness, caveats). Works with ONE connected channel; an unconnected platform carries an honest not-connected state, never zeros. Requires the caller own autario account (API key or OAuth) with at least one social connector | see get_app_context("social-360").

Publish the caller's OWN social drafts on the caller's OWN channels through the official APIs (spec 2026-11-09-own-channel-publish): the X account connected to this autario account (POST /2/tweets) and the LinkedIn company page of the connected LinkedIn login (POST /rest/posts with the organization id of the LinkedIn connector). The drafts are the rows of the account's private dataset `social_drafts` (columns drafted_at, channel x|linkedin, topic, draft, data_source, link, status, posted_at, plus post_url and error once published), which the daily social routine writes with status draft. Four actions: `targets` lists the channels (connection, can_publish, and the reason plus a connect URL when it cannot post yet: not connected, the login did not grant tweet.write / w_organization_social, no organization id on the LinkedIn connector); `drafts` returns the rows; `approve` {draft_id} flips ONE row from draft (or failed, skipped) to approved after checking the channel and the text length (X 280 weighted characters with every URL counting 23, LinkedIn 3000); `run` publishes every approved row now, one per channel, exactly once (the row is set to posting before the request and never taken twice), writes status posted + posted_at + post_url and one row into the account's `social_posts` dataset (day, channel, url, title, kind, views) that the funnel widget reads, or status failed + error with the vendor's own sentence and a bell notification. The worker runs the same `run` on the refresh cycle, so approving is enough; `run` is for "post it now". A row with status draft is NEVER published: only a person, or this tool on their behalf, approves. Own channels only: nothing here posts to Reddit, Hacker News, a forum or anybody else's thread, and nothing comments. Requires the caller's own autario account (OAuth); every row and connection is the caller's. Use when asked "post today's draft", "approve the LinkedIn draft", "which channels can autario post to", "publish the approved posts now".

Take an app YOU own back to private: it leaves the autario app store, its public URL stops working for everyone else, and only you can still open it at its preview URL, where it keeps reading World Bank, FRED and connector data as before. Nothing is deleted, and publish_app puts it back. Use it when a user wants an app off the store, or before shipping a change they do not want strangers to see.

Update the manifest of an app YOU own: its name, tagline, entry URL, version, source repository and the autario datasets or operations it is allowed to read (consumed_datasets, which is what the sandbox bridge enforces at runtime: a World Bank or FRED dataset id, a live Yahoo quote op, or the caller's own Google Search Console and GA4 connector tables). Only the fields you pass change; everything else on the manifest is kept. Use it to declare data access after create_app, to put the app on its app store shelf (shelf), to declare that reports of the app may be shared on a secret link (share), or to rename or re-point an existing app. An app you do not own answers "not found". This never changes who may open the app: publishing is publish_app, deliberately a separate act.

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.

Upload or replace the code of an app YOU own: one entry document (content: HTML or JavaScript, max 512 KB), or a bundle of files (files: index.html plus the JavaScript, CSS, images, fonts and further HTML pages it loads by relative path, max 50 files, 1 MB each, 2 MB in total; images and fonts base64). A new upload replaces the whole bundle of that version. autario stores it and serves it inside a locked sandbox with no outbound network access, so the app reads World Bank, FRED, Eurostat, SEC and connector data through autario.js (autario.query, autario.datasets, autario.artifacts) rather than calling anything itself; autario inlines the SDK into the served page, so a script tag for https://autario.com/autario.js is optional. Re-uploading the same version replaces it in place. Use it to ship a new build of an app you created with create_app, or to fix one after a user reports something.

Verify that a claimed value is correct against the primary source (World Bank, FRED, Eurostat, OECD, WHO, IMF, ECB, US Census, SEC). 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.

Answer "what explains this?" in one call: 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), so it can reach across World Bank, FRED, Eurostat, OECD, WHO and IMF series without you naming them. 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.

Which of the investors autario tracks hold a company, from their latest SEC Form 13F: value in USD, shares, weight in each portfolio and the change in shares against the prior quarter. Works for companies on the autario company roster (holdings are linked by exact issuer name); for any other security use get_investor_portfolio and filter by CUSIP. Positions are as of the quarter end, filed up to 45 days later.

Save an ARTIFACT into an app: the app's own output or saved state, owned by you. An artifact is what get_app_artifact reads back later | a Plotly chart specification, a saved report configuration, a board, a screener view, a table of World Bank or SEC figures the app computed. Give `type` (your own label, e.g. "chart", "report", "board"), a `title`, and `spec` and/or `data` as JSON. Pass `artifact_id` to patch one you already wrote instead of creating another. Use it right after create_app to seed the app with something real, or whenever a user asks you to save a view. You may write into any app you can open; someone else's private app answers "not found".

Append rows of data to an existing dataset you own (from create_dataset) | your own numbers, a derived table you computed, or a series you scraped together from World Bank / FRED / Eurostat results. 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.