# Linkio MCP tools for account callers

Generated by `node scripts/mcp-catalog.cjs` from the tool registrations; do not edit by hand.
364 tools are visible to a self-serve account key or an account sign-in (a managed account's key sees the tools its own scopes allow, write tools included).
Server: `https://mcp.linkio.com/mcp`, header `Authorization: Bearer <your key>`. Every write tool answers with `usageReceipt`; paid tools say what they hold under `usage_estimate`.
The prospecting journey needs BOTH scope pairs on the key: `prospect-pipeline:read` / `prospect-pipeline:write` (create, list and read a campaign) and `campaign:read` / `campaign:write` (everything inside it: scans, classification, types, page checks, contacts, outreach, exports). A key with only the campaign pair cannot start a campaign. A "Full access" key has all four.
Inputs are read from each tool's live schema: `name: type (required) = default`; `enum(a, b)` lists the allowed values; `array<T>` and `object { key?: T }` give the shape one level deep (`?` marks an optional key).

## Reports to Linkio

- **`report_issue`** (any key): Tell the Linkio team about a bug, a missing feature, a request or wrong data: what you tried (no secrets), what happened, what you expected. Use it when a tool is missing for what the owner needs or an error cannot be worked around, instead of working around it outside Linkio. The same problem sent again counts as a repeat, not a new report. Returns report_id; report_status shows the team's answer. Free. _Inputs: kind: enum(bug, missing_feature, request, wrong_data) (required); summary: string (required); tried: string; happened: string; expected: string; orderId: string; lineItemId: string._
- **`report_status`** (any key): Your account's reports to the Linkio team, newest first: kind, summary, status, how many times it was reported, and the team's resolution notes. Free. _Inputs: limit: integer._

## Account and money

- **`account_billing_mode`** (client-config:write): Reads (no mode) the account's billing and experience mode, with the self-serve subscription state, or moves the account to self-serve (mode 'self_serve'). Moving to the managed plan is done by Linkio's team, not here. A managed customer (an active subscription, or an order paid in the last 60 days) cannot move itself to self-serve: the read says canSwitchToSelfServe, and the move answers 403 managed_customer. Changing it is a real account setting. Needs client-config:read to read, client-config:write to change. _Inputs: mode: enum(self_serve)._
- **`account_billing_summary`** (billing:read): One financial picture of your account: recent payments, prepaid purchases, open invoices, balance. _Inputs: accountId: string (required)._
- **`account_me`** (client-config:read): Your account: id, email, contact name, company, website, billing address and status. The id is the accountId every account-scoped tool takes. The billing mode is not in it: account_billing_mode returns it.
- **`account_profile_update`** (client-config:write): Change the contact and billing details of your account: contact name, company, phone, website, tax number and billing address. Only the fields you give change; an empty string clears a field (contact name and company cannot be cleared). The email address, the password, payment methods and the billing mode do not change here. website is a full URL (https://...). Returns the account after the change. A key bound to one brand cannot change the account. _Inputs: contactName: string; companyName: string; phone: string; website: string; taxId: string; billingAddress: string; billingCity: string; billingState: string; billingZip: string; billingCountry: string._
- **`account_subscription_current`** (billing:read): Any Stripe-billed subscription still on your account: status (active, trialing, past due), its plan, the brands it covers, the current billing period and that period's usage. Pay-per-job accounts get an empty list; account_subscription_usage is the month's meter. Pass clientId to look at one brand. _Inputs: clientId: string._
- **`account_subscription_usage`** (billing:read): Your usage meter for the month: budget, spent so far, remaining, whether paid work is blocked. (Plans and link limits no longer exist; you pay per job.)
- **`billing_history`** (billing:read): Your payments, invoices and refunds, newest first, paged. _Inputs: filter: string; startDate: string; endDate: string; page: integer; pageSize: integer._
- **`credits_balance`** (billing:read): Your prepaid balance in cents, with an optional breakdown by brand pool. _Inputs: accountId: string; groupByPool: boolean._
- **`credits_by_month`** (orders:read): Credits by delivery month (budget, delivered, pending), optionally for one client (brand). _Inputs: clientId: string; months: integer._
- **`credits_convert`** (billing:write): Turns placement (link-building) credit into general credit, 1:1, one way — general credit funds AI jobs as well as orders. cents is a whole number of cents up to the convertibleCents named in a 402 or in credits_summary. Self-serve accounts only. Needs billing:write. _Inputs: cents: integer (required)._
- **`credits_create_purchase_session`** (credits:purchase): A one-time Stripe Checkout link to add money to the account, for the owner to open in a browser; card details stay with Stripe and are not part of the API. packageId is an id from credits_packages_list; without clientId the money funds the general pool. _Inputs: packageId: string (required); clientId: string._
- **`credits_packages_list`** (billing:read): The prepaid amounts you can buy, cheapest first, with their ids for credits_create_purchase_session.
- **`credits_summary`** (orders:read): Your prepaid balance now, the balance after pending deductions, and what this month spent.
- **`credits_transactions`** (orders:read): Your prepaid ledger: top-ups, charges, refunds, holds, paged. balance_after is the prepaid balance (before holds) right after the row when balance_definition is 'prepaid_v1'; on older rows it is null (their earlier figures were written under other definitions and were moved out of the column). type is earned | spent | expired. _Inputs: filter: string; startDate: string; endDate: string; limit: integer; offset: integer._
- **`credits_workflow_usage`** (orders:read): What each article cost, newest first. _Inputs: limit: integer; offset: integer._
- **`provider_key_probe`** (client-config:write): Check one provider key and store what it can serve: an OpenAI or DataForSEO check makes a few small real calls on your key (a few cents, see provider_key_probe_estimate); a Hunter, MillionVerifier or Instantly check is one free call; a QuickEnrich check is one search for a domain with no results (QuickEnrich bills only a page that has results). _Inputs: keyId: string (required)._
- **`provider_key_probe_estimate`** (client-config:read): What the capability probe of one provider key would cost on YOUR key (ids from provider_keys_list); 0 for a Hunter, MillionVerifier, Instantly or QuickEnrich key. _Inputs: keyId: string (required)._
- **`provider_key_remove`** (client-config:write): Remove one provider key from your account (ids from provider_keys_list). _Inputs: keyId: string (required)._
- **`provider_key_save`** (client-config:write): Add or replace a provider key for your account ('openai', 'hunter', 'millionverifier', 'instantly', 'quickenrich' and 'omega' take apiKey; 'dataforseo' takes login + password). The secret is sent once and never returned; the key is unverified until provider_key_probe has run on it. An Instantly key is the optional second opinion on catch-all addresses, on your key only (Linkio runs no Instantly check of its own). A Hunter key adds Hunter searches to contact discovery, on your key only (Linkio runs no Hunter search of its own). An OpenAI key the probe checked also serves the prospector's OpenAI work — outreach polish, domain classification and the topical-fit page checks — for the fee only (features on the key: 'outreach-polish', 'prospect-classify', 'prospect-enhance'). An Omega Indexer key the probe checked (an empty submission, nothing sent) serves submit-indexer for the 1c fee per accepted URL only (feature 'omega-index'). _Inputs: provider: enum(openai, dataforseo, hunter, millionverifier, instantly, quickenrich, omega) (required); apiKey: string; login: string; password: string._
- **`provider_keys_list`** (client-config:read): The OpenAI, DataForSEO, Hunter, MillionVerifier, Instantly and QuickEnrich keys on file for your account (masked, never the secret) and whether each is live. With the OpenAI and DataForSEO keys both on file the account gets the $10 free start; work on a key you own pays that provider directly.
- **`usage_api_key_caps_set`** (billing:write): Set or clear the daily and monthly spending caps of ONE account API key (ids from usage_limits_get.apiKeys). _Inputs: apiKeyId: string (required); dailyCapCents: integer | null; monthlyCapCents: integer | null; askOverCents: integer | null._
- **`usage_approvals_decide`** (billing:write): Approve or deny one job waiting under "ask me before any job over $X", by approval id (from a NEEDS APPROVAL answer or usage_approvals_list). The decision is the account owner's; this tool is marked destructive, so the client asks the person at the keyboard before the call. Result: the approval with its new status (approved or denied) and who decided. 404 unknown or another account's, 409 already decided, 410 expired. An approved job runs once when the refused call is repeated. _Inputs: approvalId: string (required); decision: enum(approve, deny) (required); accountId: string._
- **`usage_approvals_list`** (billing:read): Jobs waiting for the owner's yes under "ask me before any job over $X", plus the last decided ones, by approval id (the id a NEEDS APPROVAL answer names). The decision is the owner's: usage_approvals_decide, the billing page or the activity page. _Inputs: accountId: string._
- **`usage_billing_card_get`** (billing:read): The card on file (brand, last 4, status), how much usage is not yet charged to it, how much more can run before the next charge, and whether paid work is paused after a failed payment. The owner adds or removes a card on the billing page. _Inputs: accountId: string._
- **`usage_billing_card_remove`** (billing:write): Remove the card on file. Refused while usage is still unbilled (usage_billing_pay_now clears it). Afterwards paid work runs on the prepaid balance only.
- **`usage_billing_card_setup_link`** (billing:write): A Stripe-hosted page where the account owner enters a card; nothing is charged there and no card details pass through the API. Valid 24 hours; the result shows in usage_billing_card_get. _Inputs: returnUrl: string._
- **`usage_billing_charge_sync`** (billing:write): Fetch one card charge from Stripe again and settle it now (for a charge that shows pending or was confirmed by the bank). _Inputs: chargeId: string (required)._
- **`usage_billing_charges_list`** (billing:read): The card charges of the account, newest first: amount, reason, status, failure code, next retry. _Inputs: accountId: string; limit: integer._
- **`usage_billing_ledger`** (billing:read): The card ledger: usage accrued to the card, charges, the free start, adjustments; optionally one month. The sum is the unbilled balance. _Inputs: accountId: string; period: string; limit: integer._
- **`usage_billing_pay_now`** (billing:write): Charge the whole unbilled usage balance to the card now (automatic charges run at $5 the first time, then every $50, and on the 1st of each month). Clears the balance that blocks card removal and resumes paid work paused by a failed payment once the card was replaced.
- **`usage_estimate`** (billing:read): The price before the click: what starting N units of a feature would hold right now — 'article' (one article), 'topic_generation' (one topic session), 'target_page_ai' (one target page), 'ai_find_sites' (count = the site goal), 'website_search' (count = sites the search may return), 'site_metrics' (count = domains), 'serp_search' (count = queries of one scan). Same math as the start itself. Nothing is charged. For 'article' the hold is the average cost of Linkio's articles over the last 7 days plus margin and fees; breakdown adds typicalCents (a typical article, median-based), ownKey (what Linkio holds on your own OpenAI key, and theirOpenAiCents: about what your OpenAI bill pays) and window (days, articles). _Inputs: accountId: string; feature: enum(article, topic_generation, target_page_ai, ai_find_sites, website_search, site_metrics, serp_search, prospect_contact_discovery, prospect_email_verify, outreach_polish, prospect_classify, prospect_enhance) (required); count: integer._
- **`usage_feature_cap_set`** (billing:write): Set or remove a monthly spending cap for ONE feature of your account (prescreen, ai_find_sites, workflow_steps, topic_generation, target_page_ai, client_operations, ai_mentions, prospect_data, seo_analysis, requests, other). _Inputs: feature: string (required); monthlyCapCents: integer | null (required)._
- **`usage_jobs`** (billing:read): What you paid for in one month, one row per charge, newest first: when, which feature, what it was, whether your own provider key or Linkio's ran it, provider cost, Linkio's fee and the amount charged. Amounts in cents; default the current month. _Inputs: accountId: string; period: string; limit: integer._
- **`usage_limit_increase_request`** (billing:write): A request to Linkio to raise the monthly budget above the ceiling the account can set on its own. One open request at a time; the decision appears in usage_limits_get. _Inputs: requestedCents: integer (required); reason: string._
- **`usage_limit_increase_withdraw`** (billing:write): Withdraw your pending request for a higher spending ceiling (id from usage_limits_get.pendingIncreaseRequest). _Inputs: requestId: string (required)._
- **`usage_limits_get`** (billing:read): Your spending limits: the monthly budget, spent and held so far this month, per-feature caps, the "ask me before any job over $X" threshold, and whether new paid work is blocked. _Inputs: accountId: string; period: string._
- **`usage_limits_update`** (billing:write): Change the spending limits of your account: monthlyBudgetCents (the most Linkio may bill in a UTC month, default 5000 = $50, up to the account's ceiling, $250 by default; above it the call fails with OVER LIMIT CEILING and usage_limit_increase_request is the path to a higher ceiling), budgetMode 'hard' (new paid work stops at the budget) or 'warn' (alerts only; available after 2 successful card payments), alertThresholds (up to 5 percentages, e.g. [50, 80, 100]). Only the fields sent change. Returns the new status. Needs billing:write. _Inputs: monthlyBudgetCents: integer; budgetMode: enum(hard, warn); alertThresholds: array<integer>; askOverCents: integer | null; accountId: string._
- **`usage_receipt`** (billing:read): Where the account stands right now: spent and held this month, budget left, prepaid balance, card status, and canStartPaidWork. Free. The same object comes back as usageReceipt on every write result. _Inputs: accountId: string._
- **`usage_report`** (billing:read): Your month in totals: spend by day, by feature and by API key, request counts, most-used tools. Cents. Default the current month. _Inputs: accountId: string; period: string._

## Brands and pages

- **`client_brand_aliases_get`** (client-config:read): The brand name variants the AI Mentions checks look for in assistant answers: clientName (always included), brandAliases (spacing variants, the domain, accented forms, abbreviations) and autoIncluded. _Inputs: clientId: string (required)._
- **`client_brand_aliases_set`** (client-config:write): Replace a brand's alias list as a whole with up to 20 aliases (each trimmed, up to 100 characters); the brand's own name is always included and is not an alias. Aliases left out of the list are gone. _Inputs: clientId: string (required); aliases: array<string> (required)._
- **`client_config_readiness`** (client-config:read): Which of a brand's four settings are set, with a summary of each: topicPreference (the keyword intent the research favours), marketContext (industry, audience, buyer personas, use cases, positioning; 4,000-5,000 characters is the working size), outlinePreferences (competitor exclusions, research instructions) and factCheckInstructions. Takes clientId or orderId. Free. _Inputs: clientId: string; orderId: string; scope: enum(all, article-gen, prospecting, pathway); campaignId: string._
- **`client_config_target_pages`** (client-config:read): A brand's target pages — the pages on your site that links should point to — with their prospecting keywords, anchor keywords and descriptions. allProspectingKeywords is the list to feed into website_search. _Inputs: clientId: string; orderId: string; status: string._
- **`client_config_update`** (client-config:write): Change one brand setting: topic preference (commercial, informational, mixed...), market context (who buys and why; the text every article and topic session reads), outline preferences, fact-check instructions, or publisher pre-approval. One setting per call. _Inputs: clientId: string (required); setting: enum(topicPreference, marketContext, outlinePreferences, factCheckInstructions, engagementStatus, remediationSettings, managedBy, paymentModel) (required); data: object (required)._
- **`client_create`** (client-config:write): Add a brand to your account: name, website, optional first target pages. Returns the brand id. _Inputs: accountId: string; name: string (required); website: string (required); clientType: enum(prospect, client); description: string; targetPages: array<string>._
- **`client_excluded_domains_add`** (client-config:write): Add domains to a brand's exclusion list by hand (a backlink export, known links). URLs are accepted and reduced to their domain; domains are normalised; duplicates are skipped. Free. _Inputs: clientId: string (required); domains: array<string> (required); source: enum(manual, dataforseo)._
- **`client_excluded_domains_auto_import`** (client-config:write): Import the sites that already link to this brand (from DataForSEO) into its exclusion list, so searches do not offer them again. Incremental after the first run. Metered. _Inputs: clientId: string (required); minDR: number; limit: number; forceFullImport: boolean._
- **`client_excluded_domains_list`** (client-config:read): A brand's exclusion list, the domains site searches leave out: totalCount, sourceCounts (manual, dataforseo) and hasExclusions. With hasExclusions false a site search can return sites that already link to the brand. includeDomains returns one page of the list (limit, offset, nextOffset); domains: [...] answers which of your candidate sites are on it (checked, excludedCount). _Inputs: clientId: string (required); includeDomains: boolean; limit: integer; offset: integer; domains: array<string>._
- **`client_fact_check_instructions_get`** (client-config:read): A brand's fact-check instructions: the claims to verify, the sources to cite and how to word caveats, read by the fact-check pass on every article. Returns the version, whether it is enabled, the text and when it last changed. client_config_update writes them. _Inputs: clientId: string (required)._
- **`client_fact_check_instructions_update`** (client-config:write): Update the client's fact-check instructions. _Inputs: clientId: string (required); enabled: boolean (required); instructions: string (required)._
- **`client_li_preferences_get`** (client-config:read): Your brand's link insertion settings: whether link insertions are on, the allowed kinds (listicle, contextual, manual), how far from your niche a site may be (strict, medium, loose), and whether you approve each site and each insertion page. Also how your brand runs: your usual price per link and your stretch ceiling (cents), who writes the articles (contentSource: generate or own), who plans keywords and topics (planning: system or mine), and whether you asked for an expert. Returns the saved settings, the settings in effect, and the defaults. subscriptionId adds the settings of one of your subscriptions. Free. _Inputs: clientId: string (required); subscriptionId: string._
- **`client_li_preferences_update`** (client-config:write): Change your brand's link insertion settings. Only the fields you pass change: enabled, allowedModes (listicle, contextual, manual), crossNicheTolerance (strict, medium, loose), approval (siteApprovalRequired and insertionUrlApprovalRequired, both together). How your brand runs (brand only, not with subscriptionId; null clears one): usualPricePerLinkCents (your usual price per link, not a hard cap; both prices are compared with each site's seller price, guestPostCost in website_search, which is what a self-serve order pays for the site), stretchPricePerLinkCents (the most per link, at least the usual price; a site above your usual price comes with the reason it is worth it, and you approve every site), contentSource (generate: we write the articles; own: you send your own), planning (system: we plan keywords and topics; mine: you give them), siteSearchStop (ask, the default: your client manager asks you before it starts the month's site search; off: it starts it by itself within your prices and spend limits), keywordPick (approve, the default: you approve each article keyword; agent: your agent picks and says why in a note), expertInterest (true: a request for a link-building expert to run strategy with you; pricing on request). With subscriptionId it saves the link insertion settings for that subscription. Free. _Inputs: clientId: string (required); subscriptionId: string; enabled: boolean; allowedModes: array<enum(listicle, contextual, manual)>; crossNicheTolerance: enum(strict, medium, loose); approval: object { siteApprovalRequired: boolean; insertionUrlApprovalRequired: boolean }; usualPricePerLinkCents: integer | null; stretchPricePerLinkCents: integer | null; contentSource: enum(generate, own) | null; planning: enum(system, mine) | null; siteSearchStop: enum(ask, off) | null; keywordPick: enum(approve, agent) | null; expertInterest: boolean; howItRunsSkipped: array<enum(usualPricePerLinkCents, stretchPricePerLinkCents, expertInterest)>._
- **`client_market_context_get`** (client-config:read): A brand's market context: who buys, the competitive landscape, how the brand positions itself. Every article and topic session reads it. Returns the version, whether it is enabled, the text and when it last changed. client_config_update writes it. _Inputs: clientId: string (required)._
- **`client_market_context_update`** (client-config:write): Update the client's market context. _Inputs: clientId: string (required); enabled: boolean (required); context: string (required)._
- **`client_metrics_criteria_get`** (client-config:read): Your brand's site quality rules, used when sites are found and picked: domain rules (drMin, trafficMin, refToLinkedRatioMin, trafficCliffMax, topCountryNotIn) and page rules (orgKeywordsMin, orgTrafficMin, skipTopN), each with a tier: hard (a site that fails is left out), soft (it ranks lower) or pref (only a tie-breaker). Returns the saved rules, the rules in effect, and the defaults. subscriptionId adds the rules of one of your subscriptions. Free. _Inputs: clientId: string (required); subscriptionId: string._
- **`client_metrics_criteria_update`** (client-config:write): Replace your brand's site quality rules as a whole: pass the full set as { domain, page }, each field { value, tier: 'hard' | 'soft' | 'pref' } (field names as client_metrics_criteria_get returns them; topCountryNotIn is a list of country codes with its own topCountryNotIn_tier). With subscriptionId it saves a partial override for that subscription. A set that does not match the shape is refused (400). Free. _Inputs: clientId: string (required); subscriptionId: string; metricsCriteria: object (required)._
- **`client_outline_preferences_get`** (client-config:read): The brand's article outline preferences: whether customisation is on, competitors to leave out, custom research instructions. _Inputs: clientId: string (required)._
- **`client_outline_preferences_update`** (client-config:write): Change the brand's outline preferences; only the fields you pass change. excludeCompetitors and customInstructions are what the writer reads. _Inputs: clientId: string (required); enabled: boolean (required); excludeCompetitors: array<string>; customInstructions: string; outlineInstructions: string._
- **`client_search`** (client-config:read): List or find your brands (name, website, how many target pages and orders each has, what setup is still missing). The id returned is the clientId of the brand-specific tools. _Inputs: search: string; accountId: string; accountName: string; hasTargetPages: boolean; hasOrders: boolean; engagementStatus: string; limit: number; offset: number._
- **`target_page_fetch_backlinks`** (client-config:write): Fetch a target page's existing backlinks from DataForSEO and store them, so anchor and link planning can see what the page already has (for anchors and exclusions; its counts are DataForSEO estimates, not the page's Ahrefs link count). Metered (on your own DataForSEO key: paid to the provider). _Inputs: targetPageId: string (required); maxBacklinks: number._
- **`target_pages_add`** (client-config:write): Add target pages (URLs on your own site) to a brand. Keywords and a description are generated for each new page unless autoGenerate is false; that generation holds the 'target_page_ai' estimate per page, and the response says whether it started or why it was refused. _Inputs: clientId: string (required); urls: array<string> (required); autoGenerate: boolean._
- **`target_pages_bulk_generate`** (client-config:write): Generate prospecting keywords, anchor keywords (the seed phrases the anchor text suggestions are built from, not anchor text itself) and a description for the given target pages, in parallel in the background; returns a batchId at once and the pages fill in over 30-60 seconds (client_config_target_pages shows them). Metered, about 15c per page. generateKeywords and generateDescription (both default true) choose what is generated. _Inputs: targetPageIds: array<string> (required); generateKeywords: boolean; generateDescription: boolean._
- **`target_pages_update`** (client-config:write): Set a target page's prospecting keywords and anchor keywords by hand, free of charge (keywords the account already has, or corrections to the generated ones). Only the fields sent change. _Inputs: targetPageId: string (required); keywords: string; anchorKeywords: string._
- **`target_pages_update_status`** (client-config:write): Set the status of one or more target pages of a brand: 'active' (available for searches and topics), 'inactive' (hidden, kept) or 'completed' (reached its link goal). Returns the brand's full target page list. _Inputs: clientId: string (required); pageIds: array<string> (required); status: enum(active, inactive, completed) (required)._
- **`target_pages_update_url`** (client-config:write): Change a target page's stored URL (a trailing slash, a typo, a moved page). Keywords and description are kept as they are; order items pointing at the old URL are unchanged (line_items_update changes those). Returns the previous and the new URL. _Inputs: targetPageId: string (required); url: string (required)._

## Finding sites

- **`ai_find_sites_assign_to_items`** (orders:write): Fill the domainless items of an order from a finished site search's qualified domains (projectId from ai_find_sites_status, clientId, orderId), matching each domain's suggested target page URL to the item's target page URL (protocol, www and trailing slash ignored). Items with no match stay empty; domains with no matching item are skipped. (ai_find_sites_create_order creates new items rather than filling existing ones.) _Inputs: projectId: string (required); clientId: string (required); orderId: string (required)._
- **`ai_find_sites_cancel`** (orders:write): Stop a running site search and its child tasks. Results found so far are kept (an order is created from them when the run had one to create) and the unused part of the hold is released. _Inputs: historyRunId: string (required)._
- **`ai_find_sites_create_order`** (orders:write): Create an order from a finished site search's results when none was created automatically (the run shows completed with no orderId). Needs the run's projectId and the brand id. _Inputs: projectId: string (required); clientId: string (required)._
- **`ai_find_sites_history`** (orders:read): Your past site search runs with their ids, status and outcome: what has already been searched for each brand. _Inputs: accountId: string; source: string; limit: number._
- **`ai_find_sites_start`** (orders:write): The automated site search: for the chosen target pages of a brand it searches the inventory with their keywords, qualifies the matches, and repeats up to five rounds until the goal is met. Holds the 'ai_find_sites' estimate for the goal and charges what it uses. With orderDestination empty the results stay on the run and no order is touched; filters: maxPrice in dollars, minDR, minTraffic. With no maxPrice and no flexibility, a brand with saved prices (client_li_preferences_update) is searched at its usual price: up to its stretch ceiling when orderDestination is empty, and only up to the usual price when the run adds sites to an order (a site above your usual price reaches an order only with its reason in the site approval). Runs 5-30 minutes in the background; ai_find_sites_status reports progress. _Inputs: clients: array<object { clientId: string; goal: number }> (required); targetPageIds: array<string> (required); filters: object { maxPrice?: number; minDR?: number; minTraffic?: number; reliabilityFilter?: enum(any, reliable, owner); flexibilityPercent?: number; countries?: array<string>; minCountrySharePct?: number }; skipQualification: boolean; orderDestination: object { type: enum(new, existing, assign_existing); existingOrderId?: string }._
- **`ai_find_sites_status`** (orders:read): Progress and result of a site search run: running / completed / failed, sites found per brand against the goal, the order id when one was created, the estimate held, and what the run charged (chargedCents). A run with no orderDestination that used your brand's saved prices also lists each site found (clientResults[].sites): domain, guestPostCost (dollars) and priceBand (usual, stretch or above). _Inputs: historyRunId: string (required)._
- **`bulk_analysis_add_domains`** (bulk-analysis:write): Check candidate domains against a brand's target pages before any order is touched: each domain is recorded for the brand (in projectId, or without one in the brand's default analysis project, whose id is returned), then the analysis runs in the background: DataForSEO keyword overlap, an AI grade (high_quality, good_quality, marginal_quality or disqualified) and target page matching, about 1-3 minutes per domain. Takes clientId, domains[] and either targetPageIds[] or manualKeywords (comma-separated). run: false only records the domains (nothing is charged; start them later with bulk_analysis_requalify). Cost per domain: the provider cost plus 20% margin plus the per-site compute fee (a failed run pays the provider cost only); about 17 cents plus the compute fee is held up front. Returns projectId, domains[] with their ids and analysis { started, batchId } or why it did not start. Add the good ones to an order with line_items_add_to_order (assignedDomainId links the graded row). _Inputs: clientId: string (required); projectId: string; domains: array<string> (required); targetPageIds: array<string>; manualKeywords: string; run: boolean._
- **`bulk_analysis_requalify`** (bulk-analysis:write): Re-run the qualification pipeline (DataForSEO overlap + AI grading + target matching) on domains already recorded for a brand (bulk_analysis_add_domains, or a site's assignedDomainId on an order): resets their status to pending, optionally replaces the target page ids they are judged against, and fetches DataForSEO data for domains that have none. Metered per domain: the provider cost plus 20% margin plus the per-site compute fee. _Inputs: domainIds: array<string> (required); targetPageIds: array<string>; skipDataForSeo: boolean = false; forceFullRefresh: boolean = false._
- **`dataforseo_site_metrics`** (websites:read): Domain rank, referring domains, spam score and organic traffic for up to 200 domains, from DataForSEO. 15c per call plus 0.1c per domain, or 1.5c per domain with the traffic lookup (includeOrganic, on by default); free on your own DataForSEO key. usage_estimate feature key: 'site_metrics'. _Inputs: domains: string (required); includeOrganic: boolean; rankScale: enum(one_hundred, one_thousand); locationName: string; languageCode: string; includeBalance: boolean._
- **`website_pages_query`** (websites:read): A site's collected pages sorted by organic traffic: pageUrl, organicTrafficValue (estimated monthly visits), organicKeywordCount and the keyword position spread (pos1, pos2_3, pos4_10, pos11_20, pos21_30), with collected and collectionStatus (not-collected, processing, completed, completed-empty, error). website_pages_collect gathers the data for a site that has none. _Inputs: domain: string (required); limit: number; minTraffic: number._
- **`website_search`** (websites:read): One search of the Linkio site inventory by topic, domain or quality filters (minimum DR, traffic, maximum price). Each result carries DR, traffic, the guest post price (guestPostCost) with the sellers' spread (priceRange), and the site's record with Linkio (history: attempts, delivered, failed with reason). Sites whose only offers are time-limited are left out unless includeTimeLimited is true: Some sites keep a link live for a set time, such as 12 months. When that time ends, the link may come down and is not replaced. Their rows carry timeLimited { price (what you are charged), months }. Results are priced on your seller policy (sellerPolicy, default: your account's own, see account_seller_policy_get): linkio_default is the verified owner unless a reseller priced at least 15% below the owner is proven on the site at that price; owner_only, proven_only and cheapest leave out sites where that policy has no seller. A site added to an order with the same policy is booked with the seller and price shown. A domain lookup under a policy with no seller there returns the Linkio pick, marked sellerPolicyFallback. ownerAvailable (a verified owner sells the site) and provenSeller (a seller whose latest paid order here cost no more than its price today) filter. Each row's seller says who sells it (owner, reseller or owner_unverified), whether that seller is proven, and the owner's price when an owner offer exists. Topic and filter searches cost 0.25c per site after the first 100 sites of the day; domain lookups are free. _Inputs: topicQuery: string; domain: string; maxPrice: number; minDR: number; minTraffic: number; reliabilityFilter: enum(any, reliable, expanded, owner); sellerPolicy: enum(linkio_default, owner_only, proven_only, cheapest); ownerAvailable: boolean; provenSeller: boolean; hasGuestPost: boolean; hasLinkInsert: boolean; includeTimeLimited: boolean; clientId: string; excludeDomains: array<string>; limit: number; offset: number; sortBy: enum(relevance, dr, traffic, price_asc, price_desc)._

## Orders and placements

- **`account_publisher_invoice_mark_paid`** (orders:write): Records that you paid a publisher: method and reference. Pass invoiceId for a pending invoice (find it with account_publisher_invoices_list or line_item_invoice_get). No invoice because you paid the publisher directly? Pass lineItemId instead, with paymentMethod and paymentReference, and optionally paidAt and amount. Split invoices take paymentType blogger or reseller. No money moves and the publisher is not emailed. A line item that has a pending invoice is refused (mark the invoice), an item already paid is left as it is, a closed (cancelled) placement is refused (reopen it first), and managed orders are refused (Linkio pays those publishers). It records the same payment as the Mark paid button on the order page, and is the way to mark a publisher paid with a key. _Inputs: invoiceId: string; lineItemId: string; paymentMethod: string; paymentReference: string; paymentType: enum(blogger, reseller); paidAt: string; amount: number._
- **`account_publisher_invoices_list`** (orders:read): Publisher invoices on your orders, pending and paid: publisher, site, amount, payment link and whether the work passed QA. On a self-serve order the account pays the publisher directly. _Inputs: orderId: string._
- **`line_item_agreed_price_set`** (orders:write): Change the agreed price with the publisher on one of your self-serve sites, after you both agreed it (usually on the thread). An increase, or a decrease before the publisher submitted the published URL, applies at once; a lower price after that needs proofMessageId (the publisher's message agreeing it, from line_item_conversation_read, last 30 days), otherwise it waits as a pending proposal (pendingAgreedPrice in workflow_read). Open invoices take the new amount; if the publisher's PayPal or Payoneer link asks for the old one, ask them for a new invoice. The publisher gets a short notice from your company name. The site's list price and Linkio's charges do not change. _Inputs: lineItemId: string (required); priceCents: integer (required); reason: string (required); proofMessageId: string._
- **`line_item_attachment_read`** (orders:read): The files on one of your placements' message thread, for example a publisher's invoice PDF or a screenshot of the published post. lineItemId alone lists every message with files (messageId, date, sender type, and each file's index, name, type, size and whether it has text). With messageId and index it reads one file: the text of a PDF, DOCX, text, CSV or HTML file (up to 20,000 characters, files up to 15 MB), marked as data from an outside sender; an image comes back as the picture (PNG, JPEG, GIF, WebP). No download link. Only messages on that placement's thread (404 NOT_ON_THREAD for any other message). NOT_INBOUND: the file is on a message that was sent, not received. _Inputs: lineItemId: string (required); messageId: string; index: integer._
- **`line_item_close`** (orders:write): Close one of your self-serve placements that failed (the seller rejected it, went silent, or you placed the article elsewhere), with a reason. It leaves the order total; a seller who already had it is told the order is cancelled. Undo with line_item_reopen. Not for a placement with a published URL, a paid seller or a paid order. Only after you decided. _Inputs: lineItemId: string (required); reason: string (required)._
- **`line_item_conversation_read`** (orders:read): The message thread with a site's publisher: everything you, the publisher and Linkio have said, oldest first. _Inputs: lineItemId: string (required)._
- **`line_item_invoice_get`** (orders:read): The publisher's invoice rows for one line item: status, amount, link, dates. Empty until the publisher invoices. _Inputs: lineItemId: string (required)._
- **`line_item_message_publisher`** (orders:write): Send a message to a site's publisher (a nudge, a question about timing or their site). Emailed from your company name via Linkio; the reply comes back into the same thread. Several sites with the same publisher (lineItemIds, max 50): one email lists each site, and the message and the reply show on every site's thread. _Inputs: lineItemId: string; lineItemIds: array<string>; body: string (required)._
- **`line_item_qa_decision`** (orders:write): Pass or fail the published article on one of your self-serve sites, after workflow_verify_publication. pass moves it to payment pending; fail sends your feedback (one issue per line) to the publisher. Only after you decided. _Inputs: lineItemId: string (required); outcome: enum(pass, fail) (required); feedback: string; requestTakedown: boolean._
- **`line_item_reopen`** (orders:write): Undo line_item_close on one of your self-serve placements: its earlier status comes back. The seller is not messaged. _Inputs: lineItemId: string (required); reason: string._
- **`line_item_replace_site`** (orders:write): Move one of your self-serve placements to a new site, or another seller of the same site, with the same article, also after the seller accepted or rejected it. Without offerToken it lists the sellers of that site and what you would pay; with a token and a reason it moves the placement, tells the old seller it is cancelled, and the article waits to be sent to the new seller. Only after you chose. _Inputs: lineItemId: string (required); domain: string; offerToken: string; reason: string._
- **`line_item_sellers`** (orders:read): Every seller that can take one of your placements' sites now: owner or reseller, proven at its price, the price you would pay, which one is on it, and its track record (trackRecord: delivered of assigned and the delivery rate, a trust word: Trusted, New, Prepay required or Not recommended, and its history on this site: delivered, failed, reassigned away). Never names the seller. Use the token with line_item_switch_seller. _Inputs: lineItemId: string (required)._
- **`line_item_switch_seller`** (orders:write): Move one of your self-serve placements to another seller of the same site (a token from line_item_sellers) before the current seller accepts. You pay the listed price. Only after you chose. _Inputs: lineItemId: string (required); offerToken: string (required)._
- **`line_item_timeline_read`** (orders:read): The history of one of your placements, oldest first: status changes, the emails sent to the publisher (the article, follow-ups), messages on its thread, milestones (published URL, invoice) and site replacements. Input: lineItemId. Read only. _Inputs: lineItemId: string (required)._
- **`line_items_add_to_order`** (line-items:write): Add sites to an order: each item names the brand id and the domain, optionally the target page URL (or targetPageId), anchor text and offering type ('guest_post' or 'link_insertion'). The publisher and the site's listed price are looked up for you; prices are in cents. A time-limited site needs acceptLinkTermMonths (the term from website_search timeLimited.months) or, on a pinned offer, acceptLinkTerm: true: that is your acceptance of the term, recorded on the item. Some sites keep a link live for a set time, such as 12 months. When that time ends, the link may come down and is not replaced. assignedDomainId links a site row you already graded with bulk_analysis_add_domains (same brand). ownContent: true on an item means you write that article: no AI topic or article starts on it by itself, and you upload it with order_byoc_upload. A site added here has no keyword data or grade until analyzed: pass qualify: true to start the analysis on the new items right away (the same run and price as line_items_analyze; the response's qualification[] says whether each run started). _Inputs: orderId: string (required); items: array<object { clientId: string; assignedDomain: string; targetPageUrl?: string; anchorText?: string; anchorSuggestionId?: string; allowDuplicate?: boolean; offeringType?: enum(guest_post, link_insertion, content_refresh); publisherInsertionUrl?: string; publisherOfferingId?: string; acceptLinkTerm?: boolean; acceptLinkTermMonths?: integer; wholesalePrice?: number; estimatedPrice?: number; deliveryMonth?: string; metadata?: object; assignedDomainId?: string; targetPageId?: string; ownContent?: boolean; listicle?: boolean }> (required); reason: string; approvedWholesale: string; approvedWholesalePrices: object<integer>; qualify: boolean; allowOffPlanTarget: boolean._
- **`line_items_analyze`** (orders:write): Analyze sites on an order: DataForSEO keyword overlap with the brand's target pages, the AI grade (high_quality / good_quality / marginal_quality / disqualified), authority and target page matching, one background run per site (about 1-3 minutes each). Sites added by hand have no keyword data until analyzed. Takes orderId, clientId, optionally lineItemIds (default: every site of that brand on the order) and targetPageIds (default: all the brand's target pages). A site that already has a grade keeps it unless new keyword data is fetched; bulk_analysis_requalify forces a new grade. Cost per site: the provider cost plus 20% margin plus the per-site compute fee (a failed run pays the provider cost only); about 17 cents plus the compute fee is held up front and settled as each site finishes. Returns projectId, batchId and runCount; read the results with line_items_qualification. _Inputs: orderId: string (required); clientId: string (required); lineItemIds: array<string>; targetPageIds: array<string>._
- **`line_items_assign_domain`** (line-items:write): Put a site on an order item that has none yet: the publisher is looked up from the domain, the price from the publisher's offering, DR, traffic and qualification data are stored on the item, order totals are recalculated and the item becomes approved. Rejected when the item already has a domain or has moved past the planning statuses. (publisher_assign changes the publisher of an item that has a domain; line_items_add_to_order creates new items.) _Inputs: lineItemId: string (required); orderId: string; domain: string; domainId: string._
- **`line_items_batch_update`** (line-items:write): Change inclusionStatus and notes on up to 200 items of one order in one request (the same change as line_items_update, applied in bulk); order totals are recalculated once at the end. Target page, delivery month and anchor text are not part of this tool. orderId may be left out when the items are all on one order. _Inputs: orderId: string; updates: array<object { lineItemId: string; inclusionStatus?: enum(included, excluded, saved_for_later); notes?: string; append?: boolean }> (required); append: boolean._
- **`line_items_conversations_batch`** (line-items:read): The publisher conversations of up to 50 order items in one call. mode 'summary' (default): the last 5 messages plus signals (publisherHasResponded, followUpSent, escalationCount); mode 'full': the whole thread up to maxMessagesPerItem (default 50). Per item: conversationId (null when none), messageCount, lastMessageAt and the messages (sender, body as text, sent at, channel). _Inputs: lineItemIds: array<string> (required); mode: enum(summary, full); maxMessagesPerItem: integer._
- **`line_items_enrich`** (line-items:read): The sites on an order with everything the review screen shows: DR, traffic and price, why each site qualified (the reasoning and evidence against your target page), the publisher's reliability signals (verified owner, reseller status, penalties, score) and any open issue on the item. The decision view; line_items_list gives the plain rows. _Inputs: orderId: string (required)._
- **`line_items_keyword_data`** (line-items:read): The raw keyword overlap behind the sites on an order: for each domain, every keyword it ranks for that overlaps the brand's target page keywords, with position, search volume, difficulty, competition and ranking URL, plus the target pages it was analysed against and suggestedTargetUrl. Filters: domain, minPosition, minVolume, limit (default 100, max 500; truncated flags more). Only analyzed domains have data: run line_items_analyze on sites added by hand. _Inputs: orderId: string (required); domain: string; minPosition: number; minVolume: number; limit: number._
- **`line_items_list`** (line-items:read): The sites on an order with status, inclusion (included / excluded / saved for later), target page, anchor text, price and workflow id. Pass includeExcluded true for everything; lineItemId alone shows that one site. _Inputs: orderId: string; lineItemId: string; clientId: string; inclusionStatus: enum(included, excluded, saved_for_later); status: string; includeExcluded: boolean._
- **`line_items_move`** (orders:write): Move placements from one of your self-serve orders to another of your self-serve orders. Each placement keeps its article, seller, status and history; the move is written to its history and both order totals are calculated again. No money moves. lineItemIds are the full UUIDs of placements on one order; sourceOrderId can be left out (it is the order they are on). destinationOrderId is required: another order of yours that exists. With a key for the whole account, order_create makes a new order. A key bound to one brand names an order that already holds placements of that brand; an empty order is refused for it. createNewOrder is not available: with it, or with no destinationOrderId, the answer is 400 DESTINATION_REQUIRED. At most 200 placements per request (400 TOO_MANY_ITEMS). Refused for a managed account (403), and when either order is cancelled, completed, paid or has a payment in progress (409). A placement that is not yours answers 404, the same as one that does not exist. If a placement leaves the source order while the move runs, nothing moves (409 MOVE_CONFLICT): read the order again. The placements take the delivery month of the destination order when it has one. deliveryMonth and newOrderInternalNotes are not read for an account. _Inputs: lineItemIds: array<string> (required); sourceOrderId: string; destinationOrderId: string; createNewOrder: boolean; deliveryMonth: string; reason: string; newOrderInternalNotes: string._
- **`line_items_operations`** (line-items:read): Your sites across all orders at once, by where they stand with the publisher: waiting for publication, published and awaiting the link check, pending payment, or quiet for N days (staleDays). view 'summary' gives the counts. For payment, account_publisher_invoices_list is the source (invoice status pending or paid). _Inputs: publisherStatus: string; publisherStatusNot: string; status: string; statusNot: string; accountId: string; orderId: string; clientId: string; assignedTo: string; staleDays: number; hasPublishedUrl: boolean; hasInvoice: boolean; view: enum(summary); sortBy: enum(modified_at, publisher_status_changed_at, added_at); limit: number; offset: number; billingType: string._
- **`line_items_qualification`** (line-items:read): The evidence behind every site on an order: domain metrics (DR, traffic, keyword count), the qualification (status high_quality / good_quality / marginal_quality / disqualified, overlap direct / related / both / none, authority strong / moderate / weak by median position, topic scope, the AI reasoning), per target page the matching keywords with positions and a match quality (excellent / good / fair / poor), the publisher's trust signals (verified owner, reseller trust status, penalties, reliability score, issue history) and prices (estimated, wholesale, approved). Filters: inclusionStatus, clientId, qualifiedOnly, minDR. A site added by hand has no keyword data or grade until analyzed: run line_items_analyze on it (or add it with qualify: true), then read this again after a few minutes. _Inputs: orderId: string (required); inclusionStatus: enum(included, excluded, saved_for_later); minDR: number; clientId: string; qualifiedOnly: boolean._
- **`line_items_update`** (line-items:write): Change one site on an order: include / exclude / save for later (notes carries the reason), its target page, anchor text or delivery month. Excluding recalculates the order total. ownContent: true marks that you write this article (no AI topic or article starts on it by itself; upload it with order_byoc_upload); ownContent: false clears that, so AI content can be started again. lineItemId is enough: orderId may be left out (it is the item's order). _Inputs: lineItemId: string (required); orderId: string; inclusionStatus: enum(included, excluded, saved_for_later); notes: string; append: boolean; targetPageUrl: string; allowOffPlanTarget: boolean; anchorText: string; anchorSuggestionId: string; anchorProvenance: object { source: enum(person, agent, engine); via: string; by?: string | null; at: string; note?: string | null }; status: string; deliveryMonth: string; estimatedPrice: number; clearDomain: boolean; clearResolution: boolean; assignedDomain: string; offeringType: enum(guest_post, link_insertion, content_refresh); publisherId: string; publisherOfferingId: string; wholesalePrice: number; ownContent: boolean; offSystemPurchase: object { ref: string; note?: string } | null; articleTitle: string._
- **`order_article_status`** (orders:read): Where every article on an order is: waiting for a topic, not started, writing (with the current step and progress), stuck, failed, or complete — with word counts and quality warnings. One call per order. _Inputs: orderId: string (required); inclusionStatus: enum(included, excluded, saved_for_later)._
- **`order_byoc_update`** (orders:write): Change the title or the article URL of a workflow created by order_byoc_upload (any http(s) link that opens without a login). Not available on AI-written workflows, whose document is produced by Linkio. _Inputs: workflowId: string (required); title: string; articleUrl: string._
- **`order_byoc_upload`** (orders:write): Attach an article written outside Linkio to an order item, skipping AI writing: creates a workflow with every content step marked complete and ready for the publisher. articleUrl is any http(s) link that opens without a login (Google Docs, Notion, a hosted page); publishers receive it as is. Returns workflowId and the validated articleUrl. Content checks (workflow_verify_doc) run on Google Docs only. The item is then marked ownContent, so no AI topic or article is started on it. _Inputs: orderId: string (required); lineItemId: string (required); title: string (required); articleUrl: string; articleContent: string._
- **`order_create`** (orders:write): Open a new empty order for a brand. Sites reach it through line_items_add_to_order or a site search run whose orderDestination names it. sellerPolicy (optional) sets which seller its sites are booked with (linkio_default, owner_only, proven_only, cheapest); without it your account default applies. The order's billing type is the account's mode (a self-serve account's order is self_serve); billingType is not read for an account key. _Inputs: accountId: string; billingType: enum(managed, self_serve, managed_lite); deliveryMonth: string; notes: string; subscriptionId: string; clientId: string; billingPeriodStart: string; billingPeriodEnd: string; sellerPolicy: enum(linkio_default, owner_only, proven_only, cheapest); billingPeriodReasoning: string; allowSecondOrderForMonth: boolean; secondOrderReason: string._
- **`order_generate_invoice`** (billing:write): Creates the invoice for one of your managed orders (action generate_invoice). Self-serve orders have no Linkio invoice: you pay publishers directly. _Inputs: orderId: string (required); cancelUnusedItems: boolean; regenerate: boolean; reason: string; poNumber: string | null; customerReference: string | null; note: string | null._
- **`order_get`** (orders:read): One order in full: state, pricing, and every site on it with its status, target page, anchor text, publisher status and article workflow id. On a managed order the publisher status is the placement's progress (publisher.status and publisher.progress, e.g. "Article Sent to Publisher", "Published - Under Review", "Completed", "Cancelled"). On a managed-lite order the account pays the seller, so the status also shows the payment step (payment_pending, paid) and whether it was prepaid. view 'full' adds each article's current step. _Inputs: orderId: string (required); view: enum(summary, full)._
- **`order_list`** (orders:read): Your orders, newest first, with state, brand names and how many sites are included, in progress and done. Filter by brand id or state; search by order id or brand name. _Inputs: state: string; billingType: enum(managed, self_serve, managed_lite); accountId: string; clientId: string; search: string; assignedTo: string; includeTest: boolean; excludeInternalOnly: boolean; sort: enum(newest, oldest, updated); limit: number; offset: number._
- **`order_refresh_pricing`** (orders:write): Refresh the sites on an order with the sellers' current prices and the latest DR and traffic, and recompute the order total. A site that already has a publisher keeps the price agreed with that publisher (change it with line_item_agreed_price_set). _Inputs: orderId: string (required); lineItemIds: array<string>; category: string._
- **`order_submit`** (orders:write): Submit a draft order so work can start on its included sites. The order must have at least one included site; totals are computed from the included sites at this moment. _Inputs: orderId: string (required)._
- **`order_triage`** (orders:read): What needs attention on one of your orders, per placement: the problem (problemType, severity, reason, days since it started), the suggested action, and replacement sites where a replacement is possible; summary gives the counts. The same list as the order page. Input: orderId. Read only. _Inputs: orderId: string (required)._
- **`replacement_status`** (orders:read): For sites that were credited back (publisher failed), the replacement site and where it stands — delivered, in progress, stuck, or not yet replaced. _Inputs: orderId: string; accountId: string._
- **`site_approval_batch_add_items`** (line-items:write): Add order items to a pending site approval batch of a brand (batchId from site_approval_batch_list). Ids already in the batch are ignored; a submitted batch, or one on a closed order, cannot change. _Inputs: clientId: string (required); batchId: string (required); lineItemIds: array<string> (required)._
- **`site_approval_batch_list`** (orders:read): A brand's site approval batches: per batch the id, orderId, status (pending / submitted / closed / cancelled; closed = the order is completed or cancelled), storedStatus and orderStatus, delivery month, counts (total, approved, rejected, pending), the sites (domain, target page, anchor text, inclusion status) with the brand's notes, respondedAt and expiresAt. _Inputs: clientId: string (required)._
- **`site_approval_batch_remove_items`** (line-items:write): Remove order items from a pending site approval batch of a brand: the batch total is recomputed from the remaining included items, its approved and rejected lists are cleaned, and an emptied batch is deleted. The items themselves are untouched. A submitted batch, or one on a closed order, cannot change. _Inputs: clientId: string (required); batchId: string (required); removeLineItemIds: array<string> (required)._

## Topics and articles

- **`anchor_plan_get`** (article-gen:read): A target page's anchor text plan: the mix of anchor types it aims for, the mix its live links actually have, and the gap per type. Anchor suggestions follow this plan. _Inputs: targetPageId: string (required)._
- **`anchor_plan_update`** (article-gen:write): Change a target page's anchor text plan, the same write as the anchor page's "Customize %" editor: planId alone assigns that plan (page overrides cleared); customOverrides gives this page its own percentages (keys = anchor types, whole-number percent, total exactly 100, types left out count as 0, unknown types rejected; keeps the current plan unless planId is given); clearOverrides true returns the page to the plan's percentages. Marks the assignment manual (AI Optimize keeps it) and re-ranks the page's active suggestions at once. Returns the updated plan summary and topSuggestions in the new order. _Inputs: targetPageId: string (required); planId: string; customOverrides: object<integer>; clearOverrides: boolean._
- **`article_gen_anchor_apply`** (article-gen:write): Set the anchor text of one workflow or line item (lineItemId when no workflow exists yet) from a suggestion (suggestionId, which marks it used so it is not assigned twice) or from customAnchorText. Stored on the line item and synced to the workflow; clears the no_anchor_text blocker in article_gen_readiness. Text that reads as a URL of another site, or of a page other than the target page, is refused (anchor_url_mismatch) and nothing is written; the site's homepage URL is accepted. _Inputs: workflowId: string; lineItemId: string; suggestionId: string; customAnchorText: string; anchorProvenance: object { source: enum(person, agent, engine); via: string; by?: string | null; at: string; note?: string | null }._
- **`article_gen_anchor_dismiss`** (article-gen:write): Remove one or more anchor text suggestions from the active pool, with a reason that is kept; the next-best suggestion takes their place in article_gen_anchor_suggestions. _Inputs: suggestionIds: array<string> (required); reason: string._
- **`article_gen_anchor_generate`** (article-gen:write): mode 'generate': produce anchor text suggestions for one target page across the 13 anchor types from its anchor keywords, its current backlink profile (DataForSEO) and the gap per type, waterfall-ordered and stored; runs in the background (metered, about 20c) and returns a runId whose status (pending, running, completed, failed) the same tool reports when called with targetPageId and runId. mode 'refresh': re-rank the existing suggestions against the current anchor distribution, free and immediate. A page with empty anchorKeywords gets its keywords generated as part of 'generate'. _Inputs: targetPageId: string (required); mode: enum(generate, refresh) (required); runId: string; skipBacklinkFetch: boolean._
- **`article_gen_anchor_suggestions`** (article-gen:read): The anchor text roadmap for an order (or one workflow): every included site grouped by target page, each with a recommendedSuggestion (suggestedText, anchorType such as exact_keyword / branded / partial_keyword, priority, rationale, category) and its suggestion id; allSuggestions=true adds each page's full ranked list. Items without a workflow appear with workflowId null, so anchor text can be set before topic research. Per target page: needsGeneration true means no active suggestions exist yet (article_gen_anchor_generate creates them), isStale true means they predate the latest backlink data; distributionSnapshot gives current vs target percentages per anchor type. Suggestions are pre-ordered by a waterfall that simulates sequential assignment, so each item's recommendation already accounts for the others. Needs anchor keywords on the target pages (client_config_target_pages shows anchorKeywords). Free. _Inputs: orderId: string; workflowId: string; allSuggestions: boolean; targetPageId: string._
- **`article_gen_batch_start`** (article-gen:write): Write the articles for several sites at once (each holds the 'article' estimate; sites that are not ready are skipped and named in the response). _Inputs: workflowIds: array<string> (required); modelTier: enum(standard, value, premium) = "standard"._
- **`article_gen_readiness`** (article-gen:read): Whether an order's sites (or one workflow) can start writing, with the exact blocker when not: topic research unfinished, anchor text missing, an anchor that reads as a URL of another site or page than the target page (anchor_url_mismatch), target page missing, or already writing. Free. _Inputs: orderId: string; workflowId: string._
- **`article_gen_set_anchor_text`** (article-gen:write): Write a custom anchor text straight onto a workflow or line item (lineItemId when no workflow exists yet), outside the suggestion system, so nothing is marked used. For text that matches no suggestion. Text that reads as a URL of another site, or of a page other than the target page, is refused (anchor_url_mismatch); the site's homepage URL is accepted. _Inputs: workflowId: string; lineItemId: string; anchorText: string (required); anchorProvenance: object { source: enum(person, agent, engine); via: string; by?: string | null; at: string; note?: string | null }._
- **`article_gen_start`** (article-gen:write): Write the article for one site: research, draft, audit, fact-check, polish, links and images, then a Google Doc. Holds the 'article' estimate and charges per step as it goes. Takes 15-30 minutes; article_gen_status reports progress. _Inputs: workflowId: string (required); modelTier: enum(standard, value, premium) = "standard"; approvalTaskId: string._
- **`article_gen_status`** (article-gen:read): Writing progress for up to 20 workflows: running / paused / completed / failed, the current step, percent done, and the error when one failed. _Inputs: workflowId: string (required)._
- **`topic_gen_candidates_decide`** (topic-gen:write): Your decision on a keyword proposed for one of your sites: approve or reject one proposal (candidateId from topic_gen_candidates_read, decision approved or rejected, note = your reason, kept as written), or approve every rank 1 pick on an order at once (approveAgentPicks with orderId or lineItemIds). Approving writes the keyword on that site and starts its title suggestions; triggerTitles false writes the keyword only. On a self-serve account only a proposal that waits for a decision can be decided (409 otherwise); approving one that is already approved starts nothing again. A FAILED line at the top means the keyword did not reach the site or its titles did not start; approving the same proposal again retries it. _Inputs: candidateId: string; decision: enum(approved, rejected); note: string; triggerTitles: boolean; approveAgentPicks: boolean; orderId: string; lineItemIds: array<string>._
- **`topic_gen_candidates_read`** (topic-gen:read): The keyword proposed for each of your sites that waits for your decision: the keyword, the site, the target page and anchor text, the evidence behind the pick, the reason in plain words, and the runner-up it beat (rank 1 is the pick, rank 2 and up the runners-up). workflowId gives one site, orderId every site on one order; status limits it to proposed, approved, rejected or superseded. jobId and clientId do not apply to your account. A site waiting for this shows 'candidate_approval' in topic_gen_order_status. Free. _Inputs: jobId: string; clientId: string; orderId: string; workflowId: string; status: string._
- **`topic_gen_finalize_keyword`** (topic-gen:write): Approve up to ten keyword candidates for one site; the approved ones get scored (topic_gen_phase23_scores). Not the final pick. _Inputs: workflowId: string (required); keywords: array<string> (required)._
- **`topic_gen_order_status`** (topic-gen:read): Topic research progress per site: phase, what it is waiting for (keyword choice, title choice), the chosen keyword and title, and which sites are ready to start. inclusionStatus 'included' limits it to the working set. _Inputs: orderId: string; workflowId: string; activeOnly: boolean = true; inclusionStatus: string; topicGenReady: boolean._
- **`topic_gen_pending_keywords`** (topic-gen:read): For one site: the topics that site actually ranks for, the keyword candidates with rationale and their search volume, and the ten picked automatically. One site per call. _Inputs: orderId: string; workflowId: string._
- **`topic_gen_phase23_scores`** (topic-gen:read): For one site, the scores of the approved keywords: authority, relevance and strategy out of 10 each, plus how hard the current results are to beat. _Inputs: orderId: string; workflowId: string._
- **`topic_gen_phase4_titles`** (topic-gen:read): For one site, after the keyword is set: title suggestions with the rationale behind each. _Inputs: orderId: string; workflowId: string._
- **`topic_gen_reset_session`** (topic-gen:write): Clear a workflow's topic research session and set its topic step back to pending so research starts over (a wrong keyword, a stuck session). _Inputs: workflowId: string (required); reason: string._
- **`topic_gen_start`** (topic-gen:write): Start topic research for included sites on an order: the site's own authority is analysed and about 60 keyword candidates are produced per site. Holds the 'topic_generation' estimate per site and charges what it uses. Runs 2-5 minutes in the background; topic_gen_order_status reports progress. A site marked ownContent (you write that article) is skipped with code own_content; overrideOwnContent: true starts it anyway and clears the mark. _Inputs: orderId: string (required); lineItemIds: array<string> (required); skipPreflightCheck: boolean = false; mode: enum(agent, standard); overrideOwnContent: boolean._
- **`topic_gen_start_phase4`** (topic-gen:write): Set the one final keyword for a site after the scores and start title suggestions; they are ready in 2-3 minutes in topic_gen_phase4_titles. _Inputs: workflowId: string (required); selectedKeyword: string (required)._
- **`topic_gen_submit_title`** (topic-gen:write): Set the article title and keyword for one site and finish topic research for it (the research brief is then prepared in the background). One site per call. articleType 'listicle' marks a list-style topic. _Inputs: workflowId: string (required); title: string (required); keyword: string (required); articleType: enum(default, listicle) = "default"; approvedBy: string._
- **`topic_gen_target_urls`** (topic-gen:read): The target page URL each workflow links to, resolved from the order item, the workflow, the brand's defaults or the target pages table in that order. Free. _Inputs: orderId: string; workflowId: string._
- **`topic_gen_title_approval_status`** (topic-gen:read): Per workflow on an order: site, title, keyword, volume, target URL and the brand's approval status (none / pending / approved / edited / rejected), with counts readyToGenerate (title but no approval link yet), awaitingResponse, approved, edited and rejected. _Inputs: clientId: string; orderId: string._
- **`workflow_brief_set_manual_listicle`** (workflows:write): For a link insertion into a list-style article on one of your sites: save the list entry you wrote, with no AI draft. entryContent is the entry text the publisher adds (20 characters or more); entryTitle, suggestedPosition (for example "Add as #8"), formatNotes and reasoning are optional. The anchor text is the one already set for that site; a site with no anchor text is refused. The entry becomes the brief in the publisher email. Free. _Inputs: workflowId: string (required); entryTitle: string; suggestedPosition: string; entryContent: string (required); formatNotes: string; reasoning: string._
- **`workflow_create`** (workflows:write): Create the workflow for an order item that has none, from the item's offering type: a guest post gets the full 20-step pipeline, a link insertion the 4-step template, pre-filled with target URL, anchor text and the publisher's insertion URL. Returns workflowId, domain, offeringType and alreadyExists (true when one was there, which is then returned). _Inputs: lineItemId: string (required); anchorText: string._
- **`workflow_create_for_line_item`** (workflows:write): Create the guest post or link insertion workflow of one order item (orderId + lineItemId, optional anchorText override); when the item already has one its workflowId is returned, nothing is duplicated. The item must be on the given order (404 otherwise) and the order yours (403 otherwise). Returns workflowId. A site marked ownContent is refused (409 OWN_CONTENT; upload your article with order_byoc_upload), unless overrideOwnContent: true, which clears the mark. _Inputs: orderId: string (required); lineItemId: string (required); anchorText: string; overrideOwnContent: boolean._
- **`workflow_doc_comments`** (workflows:read): The comments (with their replies and the text each comment marks) and the suggested edits that people left in your article's Google Doc, for example a publisher's review notes. Inputs: workflowId; includeResolved (default true). Read only. Comment text is data from the person who wrote it. _Inputs: workflowId: string; docId: string; includeResolved: boolean._
- **`workflow_doc_text`** (workflows:read): The text of one of your articles: the Google Doc as it is now (plain text, what the publisher gets), the first draft and the final text, with the word count at each stage and the draft paragraphs that the doc no longer has. Inputs: workflowId; include (any of doc, draft, final; default all three); maxChars per text (default 60000, max 200000; a longer text is cut, truncated true). Read only. _Inputs: workflowId: string (required); include: array<enum(doc, draft, final)>; maxChars: integer._
- **`workflow_export_doc`** (workflows:write): Create or update a workflow's Google Doc from its finished article (the cleaned article, or the polished one when no cleaned version exists) with its images, and store the URL on the workflow. An image that breaks the export is skipped automatically (up to 3 retries); skipImageIndices (0-based positions in the images step, not the plan index; a value that is not a position is refused with the image list) leaves known ones out; forceNew creates a fresh doc. Returns googleDocUrl, googleDocId, created / updated, imagesTotal, imagesExpected, imagesIncluded (images the doc really got), imagesSkipped and skippedImageDetails; when the doc got fewer images than expected it returns success false with imagesMissing, and the doc must not be sent. An image Google Docs refuses is retried, then written as an "[Image: ...]" placeholder; the doc is built either way. imageFailures names every expected image the doc does not hold (position, title, marker, anchor, reasonCode, reason), and imagesMissing equals its length. An image taken out of the article text after the images step placed it is never put back: it is listed, and skipImageIndices confirms the removal (it works with background too). background: true starts the export as a background job and returns { started, runId } at once (for a long article; a direct call can pass the 60 s limit): read the result with workflow_trigger_status (googleDocExport: status queued / running / done / failed, googleDocId, error). The automatic export after writing records its result there too. _Inputs: workflowId: string (required); skipImageIndices: array<number>; forceNew: boolean; background: boolean; approvalTaskId: string; allowCut: boolean; cutApprovalTaskId: string._
- **`workflow_generate_brief`** (workflows:write): For a link insertion: write the short insertion brief for the publisher's existing article (a listicle entry or a contextual sentence, chosen from the page's format). The brief is what the publisher email carries. _Inputs: workflowId: string (required); mode: enum(listicle, contextual); originalContent: string; publisherPageUrl: string; targetUrl: string; preferredAnchorText: string; insertionStrategy: enum(ai-choice, minimal-single-sentence, light-edit, natural-addition, paragraph-rewrite, section-expansion, aggressive-rewrite, minimal-1-sentence, natural-2-3-sentences); targetPageSummary: string; approvalTaskId: string._
- **`workflow_generate_contextual`** (workflows:write): For a link insertion into an ordinary article: find the natural spot and draft the one to three sentences that carry your link with the agreed anchor. _Inputs: workflowId: string (required); originalContent: string; publisherPageUrl: string; targetUrl: string; preferredAnchorText: string; insertionStrategy: enum(ai-choice, minimal-single-sentence, light-edit, natural-addition, paragraph-rewrite, section-expansion, aggressive-rewrite, minimal-1-sentence, natural-2-3-sentences); targetPageSummary: string; approvalTaskId: string._
- **`workflow_generate_listicle`** (workflows:write): For a link insertion into a "Top N" style article: draft a new entry that matches the existing entries' style and carries your link. _Inputs: workflowId: string (required); originalContent: string; publisherPageUrl: string; targetUrl: string; preferredAnchorText: string; approvalTaskId: string; positionPolicy: enum(suggest, any)._
- **`workflow_generate_listicle_sync`** (workflows:write): Same as workflow_generate_listicle, waiting for the result and writing it into the brief the publisher email uses. _Inputs: workflowId: string (required); force: boolean; timeoutMs: integer; originalContent: string; publisherPageUrl: string; targetUrl: string; preferredAnchorText: string; approvalTaskId: string; positionPolicy: enum(suggest, any)._
- **`workflow_image_view`** (workflows:read): One image of your article: the picture (an image block, long edge at most 1568 px) and its facts (index, file name, title, alt text, section, source, screenshot URL, width, height, size), plus others, the list of all the article's images. Inputs: workflowId and one of index, filename or imageId; googleDocId for the images of an earlier Google Doc of the same workflow. On account keys there is no written description of the image (describe has no effect). Read only, free. _Inputs: workflowId: string (required); index: integer; filename: string; imageId: string; describe: boolean; googleDocId: string._
- **`workflow_images_compress`** (workflows:write): Smaller copies of your article's existing images, for a publisher who does not accept large files. The pictures are encoded again, not made again: about 300 KB each (maxBytes), long edge 1200 px (maxWidth), jpeg for opaque images and png for images with transparency (format sets jpeg, webp or png); indices limits it to some images. The originals, the article text and the Google Doc do not change. Returns each image's size before and after and a public link to each copy. Free; it sends nothing. _Inputs: workflowId: string (required); maxBytes: integer; maxWidth: integer; format: enum(jpeg, webp, png); indices: array<integer>._
- **`workflow_read`** (workflows:read): One site's full workflow: view 'summary' for title, keyword, anchor, target page, publisher status, published URL, the article link (googleDocUrl: the Google Doc or your own article link), finalArticleUrl (the Details tab's "Final Google Doc URL") and agreedPriceCents (the agreed price with the publisher on a self-serve order, in cents: what the article email states and the invoice is checked against), plus pendingAgreedPrice (a lower price waiting for the publisher's confirmation, from line_item_agreed_price_set); 'steps' for every step's status; 'step' with a stepId for that step's content (for example the finished article). _Inputs: workflowId: string (required); view: enum(summary, steps, step, metadata, full); stepId: string._
- **`workflow_run_cancel`** (workflows:write): Stop the article run that is running on your workflow now. Only the run that the workflow records as running stops, with its step runs; runId (from workflow_trigger_status) is optional, and a different running run is refused (409 RUN_MISMATCH). Completed steps stay; the work on the current step is lost. Nothing new starts. When the stop is confirmed, the credit hold for the run is released (billing in the answer). The steps the run finished were charged when they finished; the stopped step is charged when it runs again. reason (12+ characters) is recorded with the stop. 409 NO_ACTIVE_RUN: no run is running. 409 RUN_STARTING: a run is starting now. 409 CANCEL_UNCONFIRMED: the stop was sent and is not confirmed yet (workflow_trigger_status shows when the run ends). _Inputs: workflowId: string (required); reason: string (required); runId: string._
- **`workflow_send_to_publisher`** (workflows:write): Send the finished article to the site's publisher for review and publication. Same as the Send / "Send to Publisher Portal" button in the app (the same route): the publisher gets an email with the article link and their reply lands in the thread. Works for your own articles too (order_byoc_upload: a Notion page, a Google Doc or any link that opens without a login); no button needed. workflow_verify_doc checks Google Docs only; a Notion or other link is sent as it stands. _Inputs: workflowId: string (required); lineItemId: string; articleTitle: string; googleDocUrl: string; emailSubject: string; emailBody: string; previousSiteLinkReason: string; briefRulesReason: string; resendReason: string; forceSendOverCollab: boolean; collabSkipRelease: string; acknowledgeMissingCollabLinks: boolean; privateDocReason: string; docVerifyConfirm: boolean; approvalTaskId: string; checkOnly: boolean; expectedMailTextHash: string._
- **`workflow_trigger_resume`** (workflows:write): Continue a paused or failed article from its current step (after a transient failure, or past a manual pause); skipCurrentStep true jumps over the failing step. _Inputs: workflowId: string (required); mode: enum(agentic, manual, hybrid); skipCurrentStep: boolean; approvalTaskId: string._
- **`workflow_trigger_start`** (workflows:write): Start a workflow's article pipeline from a chosen step (deep-research after topic research; an earlier step after a reset). mode 'agentic' (default, fully automated), 'manual' or 'hybrid'; modelTier 'standard' (default), 'premium' or 'value'. Holds the 'article' estimate (402 with the shortfall when the account cannot fund it) and clears any previous failure. Returns runId (what workflow_trigger_status reports on), workflowId, mode, modelTier and a realtime token valid 4 hours. Your own workflows only. _Inputs: workflowId: string (required); mode: enum(agentic, manual, hybrid); startFromStep: string; stopAtStep: string; skipSteps: array<string>; modelTier: enum(premium, standard, value); approvalTaskId: string._
- **`workflow_trigger_status`** (workflows:read): The state of a workflow's pipeline run: runStatus 'running' | 'completed' | 'failed' | 'paused' | 'idle', the current step, every step's status, progress (completed, total, percent) and the error text when it failed. Research and drafting steps can each take 5-10 minutes. googleDocExport is the Google Doc export's state: status none / queued / running / done / failed, googleDocId and googleDocUrl, error, and imageFailures (images left as placeholders: do not send the doc). _Inputs: workflowId: string (required)._
- **`workflow_verify_doc`** (workflows:write): Check a workflow's Google Doc against its data. Critical checks (fail = the doc is not ready to send): anchor text present, target URL linked, the anchor linked to the target URL, no placeholder artefacts (TODO, [INSERT], template markers, assistant citations), the target URL linked exactly once, a numbered listicle title ("11 Best ...") matched by numbered item headings 1 to N with none missing, and no repeated sentence of 8+ words in the client's section or naming the client. Warnings: heading structure, intro and conclusion, FAQ when expected, word count drift over 30 percent, one to three links in the article body, repeated sentences elsewhere, images when generated. Info: word count, title match. Returns success (all critical passed), checks[] with name, passed, severity and message, and a score. Free. Google Docs only. _Inputs: workflowId: string (required); googleDocId: string; lineItemId: string._
- **`workflow_verify_publication`** (workflows:write): Tell Linkio where the article went live. The link is checked automatically: it is live, the anchor text is right, the page meets the guidelines. Results appear in workflow_read on the publication-verification step. _Inputs: workflowId: string (required); publishedUrl: string (required)._

## Plans and reports

- **`account_activity_feed`** (orders:read): What happened on your account lately: publisher status changes (on a managed order also each published URL, as a "Published" status update), messages, orders created, payments, and what the meter did — charges with their cost (usage_charge), holds placed, settled or released (hold), approvals asked for and decided (approval), workflows paused for the budget (budget_pause), budget alerts sent (budget_alert), limit changes (limits_change), and placements closed, reopened or moved to another site or seller (placement_change). On the orders you run or pay the seller for: seller invoices received (invoice_received), QA results (qa_result), sellers who rejected a placement so it needs a new site (seller_rejected), and questions waiting on you with their options (waiting_on_you). The same feed as the activity page, across every order. Every event has costCents (cents on a charge, hold or approval; null elsewhere). Filter by order, event type or days. To see only what changed since your last look, keep pagination.nextSince and pass it back as since: the events after it come oldest first, none missed or repeated. Events show up about 2 minutes after they happen. The questions open now are in account_waiting_list. Free. _Inputs: limit: number; cursor: string; since: string; offset: number; types: string; days: number; orderId: string; accountId: string._
- **`client_analysis_delete`** (client-config:write): Delete an analysis entry from a client's report. _Inputs: clientId: string (required); entryId: string (required)._
- **`client_analysis_list`** (client-config:read): The analysis entries on a brand's report page, newest first, with their text. _Inputs: clientId: string (required)._
- **`client_analysis_publish`** (client-config:write): Add a dated analysis entry (title, one-line summary, markdown body) to the brand's report page. _Inputs: clientId: string (required); date: string (required); title: string (required); summary: string; body: string (required); visibility: enum(public, internal)._
- **`client_analysis_update`** (client-config:write): Update an existing analysis entry. _Inputs: clientId: string (required); entryId: string (required); date: string; title: string; summary: string; body: string; visibility: enum(public, internal)._
- **`client_campaign_history`** (crm:read): Every topic ever researched for a brand across all its orders: usedKeywords and usedTitles (deduplicated), byTargetPage (the angles each page already has), and items with site, target page, anchor text, keyword, title, delivery month, status and published URL. targetPageUrl narrows it to one page. Free. _Inputs: clientId: string (required); targetPageUrl: string._
- **`client_report_contact_add`** (client-config:write): Add a report contact for a client. _Inputs: clientId: string (required); email: string (required); name: string._
- **`client_report_highlights`** (client-config:read): A brand's results in numbers: which keywords its links are cited for in AI assistants, which Google rankings they reached, deliveries by month, brand mentions, what is new since a date. The source of every reported figure. _Inputs: clientId: string (required); since: string; from: string; to: string; excludeAbcGives: boolean; respectPriorSendBoundary: boolean; excludePaymentStatusFlips: boolean._
- **`client_report_highlights_batch`** (client-config:read): client_report_highlights for every brand that matches a filter at once (engagementStatus 'active' default, 'paused', 'churned'; accountId): per brand the citations, Google rankings, delivery stats, brand summary and report contacts. Only brands with a report page are returned. _Inputs: engagementStatus: string; accountId: string._
- **`client_report_message_create`** (client-config:write): Write a report message for a brand as a draft, or record one you sent elsewhere. Drafts go out with client_report_message_send. _Inputs: clientId: string (required); body: string (required); tag: enum(weekly_update, general); markAsSent: boolean; sentAt: string; channel: enum(linkio_platform, spp_dashboard, external_email); deliveredUrls: array<object { domain: string; url: string; rawDateLabel?: string; anchorText?: string }>; highlightKeywords: array<string>; externalSendRef: string; sendBatchId: string._
- **`client_report_message_delete`** (client-config:write): Delete a draft report message. Sent messages are permanent and cannot be deleted. Returns success or the reason (already sent, not found). _Inputs: clientId: string (required); messageId: string (required)._
- **`client_report_message_send`** (client-config:write): Send a draft report message to the brand's report contacts that have notifications on: marks it sent and emails each contact (subject "Linkio Report — {brand}", from info@linkio.com, replies thread back into the report), with a "View Full Report" button. Returns emailsSent, emailsFailed and errors. Only a draft can be sent; a sent message cannot be sent again. _Inputs: clientId: string (required); messageId: string (required)._
- **`client_report_messages_list`** (client-config:read): The report messages written for a brand (drafts and sent), newest first. _Inputs: clientId: string (required)._
- **`client_report_sends_list`** (client-config:read): The last reports sent to one of your brands, newest first, on every channel: for each, the channel, the full text, the delivered URLs and highlight keywords it named, and when it was sent. Replies on the report thread are in the list too, with no delivered URLs. Only messages shown on your report thread are listed. limit is 1 to 20 (default 3). _Inputs: clientId: string (required); limit: integer._
- **`link_plan_activate`** (crm:write): Make a link plan the brand's active one. The brand's other active plans are completed in the same transaction. The plan's months may not overlap a scheduled plan (status 'scheduled'): that returns 400 PLAN_MONTH_OVERLAP with the conflicting plan in overlaps[]. _Inputs: clientId: string (required); planId: string (required)._
- **`link_plan_check_in`** (crm:read): The active strategy against actual delivery: per page, links delivered versus what its tier expects, an adherence verdict (on_track / missed / over_served) and the gap. Position data is whatever baseline the strategy stores (link_plan_update records a fresh one); nothing is fetched live. _Inputs: clientId: string (required)._
- **`link_plan_create`** (crm:write): Create a link building plan for a brand. Percentage mode: pageAllocations with a percent per target page. Strategy mode: a strategy object with, per page, a tier ('primary' every month, 'rotation', 'paused', 'opportunistic'), a rationale, a goal, monthlyGuidance ('every' | 'alternate' | 'quarterly') and a baseline (position, traffic, refDomains, date) for later comparison. Created inactive; link_plan_activate turns it on. _Inputs: clientId: string (required); name: string (required); pageAllocations: array<object { pageId: string; percent: number; rationale?: string }>; strategy: object { pages: object<object>; startMonth?: string; endMonth?: string; planMonths?: number; rotationBudget?: number; monthlyLinks?: integer | null; overallGoal?: string; guidance?: string; analysisDate?: string; analysisRef?: string }; status: enum(draft, active, scheduled)._
- **`link_plan_get`** (crm:read): A brand's link plans: which target pages get links each month and why; the active plan's page weights. _Inputs: clientId: string (required); status: string._
- **`link_plan_suggest`** (crm:read): A suggested spread of next month's links across the brand's target pages, from the active plan and what each page has had so far. Computed on request, not stored; the order setup is free to differ. _Inputs: clientId: string (required); slots: integer; month: string._
- **`link_plan_update`** (crm:write): Change a link plan's allocations or strategy (page tiers, new pages, baselines, rationale, percentages); only the fields sent change and a new version of the plan is recorded. _Inputs: clientId: string (required); planId: string (required); name: string; pageAllocations: array<object { pageId: string; percent: number; rationale?: string }>; strategy: object { pages?: object<object>; startMonth?: string; endMonth?: string; planMonths?: number; rotationBudget?: number; monthlyLinks?: integer | null; overallGoal?: string; guidance?: string; analysisDate?: string; analysisRef?: string }; changeNotes: string; status: enum(scheduled, draft, completed, archived)._
- **`search_queries_batches`** (search-queries:read): The import batches of a brand's search queries: source, period, query count, notes, when fetched, and each batch's id. _Inputs: clientId: string (required)._
- **`search_queries_delete_batch`** (search-queries:write): Delete one import batch of search queries and every query in it (ids from search_queries_batches or search_queries_summary.latestBatch). _Inputs: batchId: string (required)._
- **`search_queries_import`** (search-queries:write): Import search-query data for a brand (Search Console exports, keyword tools, or your own list), tied to target pages by URL. _Inputs: clientId: string (required); source: string (required); sourceDetail: string; periodStart: string (required); periodEnd: string (required); notes: string; queries: array<object { targetPageUrl?: string; targetPageId?: string; query: string; wordCount: number; clicks?: number; impressions?: number; position?: string; ctr?: string; searchVolume?: number; cpc?: string; competition?: string }> (required)._
- **`search_queries_import_csv`** (search-queries:write): Imports search queries from a CSV file sent inline as file { filename, contentBase64 } (the bytes, base64-encoded; max 25MB). filePath (a path on the server's own machine) works only on a local stdio server; the hosted server answers an error for it. _Inputs: clientId: string (required); file: object { filename: string; contentBase64: string; contentType?: string }; filePath: string; source: string (required); sourceDetail: string; periodStart: string (required); periodEnd: string (required); notes: string; csvFormat: string._
- **`search_queries_list`** (search-queries:read): The search queries stored for a brand or one target page, sorted by impressions, with text, metrics, source (gsc, dataforseo, ...) and target page. Filters: targetPageId, source, minWordCount, limit. _Inputs: clientId: string (required); targetPageId: string; source: string; minWordCount: number; minImpressions: number; limit: number._
- **`search_queries_regenerate_brief`** (search-queries:write): Rebuild the keyword intelligence brief of one target page from its stored search queries (two model calls, about 90 seconds; metered) and cache it on the page, where topic research reads it. A new query import clears the cached brief by itself; this call forces a rebuild without one. _Inputs: targetPageId: string (required); clientId: string (required)._
- **`search_queries_summary`** (search-queries:read): Whether a brand has search query data: hasData, totalQueries, targetPagesWithData and the latest import batch. _Inputs: clientId: string (required)._
- **`whitelabel_report_publish`** (client-config:write): Publish an HTML report on your white-label domain, at https://<your domain>/r/<slug>, with your brand header and hidden from search engines. Give html, or sourceUrl (an https page on a public address, read once by the server; no redirects; 5 MB at most, else 413). clientId (optional) tags the report with one of your brands; a key bound to one brand always tags that brand. slug (optional; letters, digits, - and _) is the URL path; without it, a random slug that cannot be guessed is made. A second publish with the same slug replaces that report and keeps its brand when clientId is left out; a key bound to one brand replaces only a report of that brand (409 otherwise). accountId and domain can be left out: the report goes on your own account. Returns slug, url and path; while your custom domain is not active yet, url is null and domainPending is true (the report is kept and shows once the domain is active). _Inputs: accountId: string; domain: string; html: string; sourceUrl: string; slug: string; title: string; clientId: string._

## AI Mentions

- **`citation_check_curate_keywords`** (citation:write): Edit one backlink's tracking keywords in one call: deleteKeywordTexts removes keywords, addKeywords adds curated ones, setPrimaryKeywordText names the primary, clearOldChecks true deletes that backlink's citation checks (keywords stay) so the next run re-checks it. _Inputs: clientId: string (required); lineItemId: string (required); deleteKeywordIds: array<string>; deleteKeywordTexts: array<string>; setPrimaryKeywordId: string; setPrimaryKeywordText: string; addKeywords: array<object { keyword: string; isPrimary?: boolean }>; clearOldChecks: boolean._
- **`citation_check_extract_keywords`** (citation:write): Generate tracking keywords (a primary keyword plus short, mid and long-tail variations) for a brand's backlinks that have none, from each backlink's URL, page title and anchor text. Metered, about 1c per backlink. Returns counts per source (found, extracted, errors) and totalExtracted. citation_check_readiness shows how many lack keywords. _Inputs: clientId: string (required)._
- **`citation_check_index_status`** (citation:read): Google index status for every backlink of a brand: url, domain, source (imported / order), isIndexed, resultCount, lastChecked (null when never checked), and a summary (total, indexed, notIndexed, unknown, neverChecked). Citation checks on unindexed backlinks find nothing, which this view shows in advance. Free. _Inputs: clientId: string (required)._
- **`citation_check_readiness`** (citation:read): For a brand: how many delivered links have never been checked for AI citations, how many lack keywords, and what a check would cost. Free. _Inputs: clientId: string (required)._
- **`citation_check_reset_keywords`** (citation:write): Two deletions. With lineItemId: remove that backlink's tracking keywords and, with deleteCitationChecks true, its citation checks, so new keywords can be extracted and checked. With orphanKeywords[] (up to 100): remove brand-scoped checks for those keywords that are tied to no backlink and no import (the rows baseline runs leave behind); checks tied to a backlink are never touched. Returns the counts deleted. _Inputs: clientId: string (required); lineItemId: string; deleteCitationChecks: boolean; orphanKeywords: array<string>._
- **`citation_check_results`** (citation:read): The three outcomes for a brand's order backlinks in one call: AI citations (was the backlink URL cited as a source), brand mentions (was the brand named in the answer) and Google rankings (does the backlink rank for the keyword). Per backlink plus a summary: totalBacklinks, backlinksCited, backlinksBrandMentioned, backlinksWithGoogleRankings, page1Rankings, topRankings. since (ISO date) and batchId narrow the AI checks; ranking data is always included. _Inputs: clientId: string (required); since: string; batchId: string._
- **`citation_check_run_index_check`** (citation:write): Check whether specific URLs are indexed by Google (cached for 7 days). Metered per URL. _Inputs: urls: array<string> (required); clientId: string._
- **`citation_check_status`** (citation:read): Status of one citation check batch (batchId from citation_check_trigger): isComplete, progress percent, counts pending / processing / completed / failed / cited, and once complete the citationRate and citedKeywords. Counts AI citations only; Google rankings are in citation_check_results. _Inputs: clientId: string (required); batchId: string (required)._
- **`citation_check_trigger`** (citation:write): Run AI citation checks on a brand's unchecked links across the assistants. dryRun true returns the cost and runs nothing; metered, and the final cost is usually below the hold. Returns a batchId that citation_check_status reports on. _Inputs: clientId: string (required); tier: enum(economy, standard, premium); maxKeywordsPerBacklink: number; providers: array<string>; includeSerpCheck: boolean; dryRun: boolean; gapFill: boolean; forceRecheck: boolean; onlyOrderBacklinks: boolean._
- **`citation_pipeline_status`** (citation:read): The whole citation pipeline for a brand in one view, per backlink: indexStatus (isIndexed, lastChecked, stale after 7 days), omegaStatus (submitted, rechecked, due), citationStatus (hasKeywords, checksCompleted, citationsFound, lastChecked) and one action: ready, needs_index_check, needs_omega_submit, needs_omega_recheck, awaiting_omega, needs_keywords, needs_citation_check or not_indexed. The summary counts each action and lists recommendedActions in order with the URLs each one covers. Free. _Inputs: clientId: string (required)._
- **`citation_prep`** (citation:write): Prepare a brand's published backlinks for citation checks in one run: lists order backlinks with a published URL, skips those with a valid check (made while known-indexed), runs Google index checks on the rest (metered, about 1c per URL), and reports which are ready. dryRun true previews without spending. Returns readyForCitation, alreadyChecked, needsIndexCheck (dry run), submittedToOmega, awaitingOmega, stillNotIndexed, a summary, the actions executed and the cost in cents. Indexer submissions are not made from an account call (omegaSkippedReason says so); publisher_submit_indexer does that. _Inputs: clientId: string (required); dryRun: boolean._
- **`client_llm_backlink_delete`** (llm-tracking:write): Soft-delete imported backlinks (sets deleted_at). _Inputs: clientId: string (required); backlinkIds: array<string> (required)._
- **`client_llm_backlink_extract_keywords`** (llm-tracking:write): Extract keywords for a specific set of backlinks. _Inputs: clientId: string (required); backlinkIds: array<string> (required); source: enum(imported, order) (required); force: boolean; preview: boolean._
- **`client_llm_backlink_history`** (llm-tracking:read): Historical citation results for a single backlink (lineItemId). _Inputs: clientId: string (required); lineItemId: string (required)._
- **`client_llm_backlink_keyword_add`** (llm-tracking:write): Add a keyword to a single backlink's (line item's) tracked LLM-citation list. _Inputs: clientId: string (required); lineItemId: string (required); keyword: string (required); inheritFromClientScopedKeyword: boolean; category: string | null; keywordGroups: array<string>; externalMetrics: object; additionalKeywordGroups: array<string>._
- **`client_llm_backlink_keyword_delete`** (llm-tracking:write): Remove a keyword from a backlink's tracked list. _Inputs: clientId: string (required); lineItemId: string (required); keyword: string (required)._
- **`client_llm_backlink_keywords_list`** (llm-tracking:read): List keywords tracked for a single backlink. _Inputs: clientId: string (required); lineItemId: string (required)._
- **`client_llm_backlink_tags_set`** (llm-tracking:write): Add or remove tags on backlinks for filtering/grouping. _Inputs: clientId: string (required); backlinkIds: array<string> (required); tagsToAdd: array<string>; tagsToRemove: array<string>._
- **`client_llm_backlinks`** (llm-tracking:read): List published backlinks for a client with citation status. _Inputs: clientId: string (required)._
- **`client_llm_check_async`** (llm-tracking:write): Run an AI Mentions check: ask ChatGPT, Claude, Gemini, Perplexity and others your brand's prompts and record whether they cite your page (anchored to a placed link with lineItemId, or mode 'baseline' for a brand-level reading before any placement). Metered per provider × prompt; client_llm_check_cost_estimate gives the number. Returns a batchId that client_llm_check_status reports on. _Inputs: clientId: string (required); keywords: array<string> (required); providers: array<enum(chatgpt, perplexity, claude, gemini)> (required); lineItemId: string; importedBacklinkId: string; mode: "baseline"; includeSerpCheck: boolean; providerConfigs: array<object { provider: enum(chatgpt, perplexity, claude, gemini); model?: string }>; keywordGroups: array<string>; forceRecheck: boolean._
- **`client_llm_check_cost_estimate`** (llm-tracking:read): What an AI Mentions check would cost before you run it, for a given list of prompts and providers. _Inputs: clientId: string (required); providers: array<enum(chatgpt, perplexity, claude, gemini)> (required); keywords: integer (required); includeSerpCheck: boolean._
- **`client_llm_check_history`** (llm-tracking:read): List historical citation-check batches for a client. _Inputs: clientId: string (required)._
- **`client_llm_check_settings_get`** (llm-tracking:read): Read a client's LLM check settings: per-provider engine config (dataforseo | openai-direct) and the searcher-location mode. _Inputs: clientId: string (required)._
- **`client_llm_check_settings_set`** (llm-tracking:write): Replace a brand's AI Mentions check settings as a whole (which assistants, and the searcher location mode: agnostic, fixed with defaultLocation, or per_keyword). The full desired state is sent each time; fields left out are reset. _Inputs: clientId: string (required); settings: object { engines?: object<object>; locations?: array<object>; locationMode?: enum(agnostic, fixed, per_keyword); defaultLocation?: object } (required)._
- **`client_llm_check_status`** (llm-tracking:read): Progress and results of an AI Mentions check: per provider, which prompts cited your page and where it ranks on Google for them. Zero citations with a Google ranking is normal early on — assistants pick pages up weeks after Google does. _Inputs: clientId: string (required); batchId: string (required)._
- **`client_llm_comparison`** (llm-tracking:read): Historical comparison data for a client's LLM citation performance over time — used to render the historical comparison chart in the UI. _Inputs: clientId: string (required); days: number._
- **`client_llm_export`** (llm-tracking:read): Export a client's full LLM citation history as CSV-shaped JSON. _Inputs: clientId: string (required); format: enum(csv); lineItemId: string._
- **`client_llm_extract_keywords`** (llm-tracking:write): Generate tracking keywords for all of a brand's backlinks that have none. Metered, about 3c per backlink, held up front. _Inputs: clientId: string (required)._
- **`client_llm_extract_keywords_status`** (llm-tracking:read): Keyword extraction progress for a brand's backlinks: how many imported and order backlinks still need keywords, how many are in flight, how many are done. _Inputs: clientId: string (required)._
- **`client_llm_import`** (llm-tracking:write): Import backlinks for a client from a list of URLs. _Inputs: clientId: string (required); source: enum(text, csv, dataforseo) (required); urls: string; data: array<object { url: string; title?: string; anchor?: string }>; targetDomain: string; options: object; campaignSource: string; extractKeywords: boolean._
- **`client_llm_import_list`** (llm-tracking:read): List recent backlink import batches for a client (last 20). _Inputs: clientId: string (required)._
- **`client_llm_import_status`** (llm-tracking:read): Progress of one backlink import batch: imported / failed / total, and the keyword extraction progress behind it. _Inputs: clientId: string (required); batchId: string (required)._
- **`client_llm_keyword_add`** (llm-tracking:write): Add one tracked keyword to a brand's baseline: the brand-scoped LLM tracking keyword pool the keyword picker and the citation checks read. _Inputs: clientId: string (required); keyword: string (required); category: string; keywordGroups: array<string>; targetPageIds: array<string>; preferredUrls: array<string>._
- **`client_llm_keyword_cloud_batch`** (llm-tracking:write): Generate an AI-powered keyword cloud across selected backlinks for a client. _Inputs: clientId: string (required); keywords: array<object { keyword: string; backlinkIds: array<string> }> (required); sourceType: enum(order, imported) (required); providers: array<enum(chatgpt, perplexity, claude, gemini)> (required); providerConfigs: array<object { provider: enum(chatgpt, perplexity, claude, gemini); model?: string }>; includeSerpCheck: boolean._
- **`client_llm_keyword_groups_list`** (llm-tracking:read): The keyword groups (tags) on a brand's tracked prompts, with how many keywords and checks each covers, sorted by reach. _Inputs: clientId: string (required)._
- **`client_llm_keyword_groups_set`** (llm-tracking:write): Bulk add/remove keyword groups (tags) on existing llm_tracking_keywords rows for a client. _Inputs: clientId: string (required); keywordIds: array<string> (required); groupsToAdd: array<string>; groupsToRemove: array<string>._
- **`client_llm_keyword_history`** (llm-tracking:read): Per-keyword historical citation results across providers and time. _Inputs: clientId: string (required); keyword: string (required)._
- **`client_llm_keyword_locations`** (llm-tracking:write): The searcher location used per prompt in per-prompt mode: list them, set one for a prompt, or pre-derive them for every prompt. _Inputs: clientId: string (required); action: enum(list, override, derive) (required); keyword: string; location: object { city?: string; region?: string; country?: string } | null; keywords: array<string>; limit: number; offset: number._
- **`client_llm_keyword_retire`** (llm-tracking:write): Take one prompt out of your brand's prompt list, or put it back (restore true). keyword names it as your prompt list shows it (or keywordId). reason (8 or more characters) is kept with it. The prompt and its past check results stay on record; it leaves your prompt list and keyword picks no longer offer it. A prompt that is the measured prompt of a group of related prompts stays in the list (409). Free, nothing is sent. _Inputs: clientId: string (required); keywordId: string; keyword: string; reason: string (required); restore: boolean._
- **`client_llm_keyword_suggest_backlinks`** (llm-tracking:read): Given a keyword, suggest backlinks that should be re-checked for citations under that keyword. _Inputs: clientId: string (required)._
- **`client_llm_keywords`** (llm-tracking:read): The prompts tracked for a brand, with their check stats and, where set, the page each prompt is meant to surface. _Inputs: clientId: string (required); includeProviderDetails: boolean._
- **`client_llm_keywords_bulk_add`** (llm-tracking:write): Add a tracked keyword to one or more backlinks. _Inputs: clientId: string (required); keyword: string (required); backlinkIds: array<object { id: string; sourceType: enum(imported, order) }> (required)._
- **`client_llm_mentions`** (llm-tracking:read): List brand mentions extracted from LLM citation responses for a client. _Inputs: clientId: string (required)._
- **`client_llm_saved_search_create`** (llm-tracking:write): Create a saved filter view for a client's LLM tracking dashboard. _Inputs: clientId: string (required); name: string (required); query: string (required)._
- **`client_llm_saved_search_delete`** (llm-tracking:write): Delete a saved search. _Inputs: clientId: string (required); searchId: string (required)._
- **`client_llm_saved_search_update`** (llm-tracking:write): Update a saved search's name and/or query. _Inputs: clientId: string (required); searchId: string (required); name: string; query: string._
- **`client_llm_saved_searches_list`** (llm-tracking:read): List saved filter views for a client's LLM tracking dashboard. _Inputs: clientId: string (required)._
- **`client_llm_share_create`** (llm-tracking:write): Create a public share link for a client's LLM tracking dashboard. _Inputs: clientId: string (required); name: string (required); expiresInDays: number | null; filterTags: array<string> | null; filterProviders: array<string> | null._
- **`client_llm_share_delete`** (llm-tracking:write): Revoke a public share link. _Inputs: clientId: string (required); linkId: string (required)._
- **`client_llm_share_list`** (llm-tracking:read): List public share links for a client's LLM tracking dashboard. _Inputs: clientId: string (required)._
- **`client_llm_stats`** (llm-tracking:read): A brand's AI Mentions dashboard: citation and brand-mention rates per provider over the last N days, average positions, and how many of your links are covered. _Inputs: clientId: string (required); days: number; campaignSource: string._
- **`llm_tracking_providers`** (llm-tracking:read): List the supported LLM providers (chatgpt, perplexity, claude, gemini) with their display names and capabilities.
- **`topic_bank_create`** (llm-tracking:write): Add one topic to a brand's topic bank by hand (phrase, target page, kind). No research score is attached; those come from the researched import. _Inputs: clientId: string (required); phrase: string (required); targetPageId: string (required); kind: enum(question, commercial); category: string; customWording: string; queueMonth: string._
- **`topic_bank_get`** (llm-tracking:read): A brand's topic bank: per target page, the vetted article topics with their stage, status (used / queued / backlog) and which placements used them. _Inputs: clientId: string (required)._
- **`topic_bank_import`** (llm-tracking:write): Import researched, finalised topics into a brand's topic bank, each tied to a target page, with its funnel stage and sources. _Inputs: restoreUndone: boolean; clientId: string (required); runTag: string (required); targetPageUrl: string; dryRun: boolean; topics: array<object { topic: string; kind: enum(question, commercial); intent?: string; category?: string; funnelScore?: integer; funnelRubric?: object; receipts?: array<object>; slot?: string }> (required)._
- **`topic_bank_update`** (llm-tracking:write): Edit one topic in a brand's topic bank: phrase, target page, kind, category, wording, queue month, or retire it. Renaming a used topic renames its history too. _Inputs: clientId: string (required); keywordId: string (required); phrase: string; targetPageId: string; kind: enum(question, commercial); category: string; wording: object { custom?: string; audited?: string; chosen?: enum(original, audited, custom) }; queueMonth: string | null; retired: boolean._

## Exchanges and partners

- **`asset_bank_add_site`** (asset-bank:write): Offer a site to exchange partners from a bare domain: finds or creates the site record, a publisher offering per requested type, the relationship and the asset bank entry in one call, under your account. confirm false previews; confirm true writes and returns websiteId and the assets created (existed true where one already was). _Inputs: domain: string (required); offeringTypes: array<enum(guest_post, link_insertion)> (required); accountId: string; clientId: string; sourceType: enum(client_site, owned_site); customName: string; monthlyQuota: integer; notes: string; pageUrls: array<object { page_url: string; status: enum(recommended, available, excluded); notes?: string }>; confirm: boolean._
- **`asset_bank_create`** (asset-bank:write): Offer one of your sites to exchange partners from an existing site + offering id (asset_bank_add_site takes a bare domain). confirm false previews; confirm true writes. _Inputs: accountId: string (required); websiteId: string (required); publisherOfferingId: string (required); sourceType: enum(client_site, owned_site, third_party, specific_url) (required); clientId: string | null; customName: string; allowedUrls: array<string>; pageUrls: array<object { page_url: string; status: enum(recommended, available, excluded); notes?: string }>; monthlyQuota: integer; visibility: enum(public, private, account_only); notes: string; confirm: boolean._
- **`asset_bank_delete`** (asset-bank:write): Delete one offered site and its page URL list. Permanent. Your own assets only. confirm false previews; confirm true writes. _Inputs: assetId: string (required); confirm: boolean._
- **`asset_bank_get`** (asset-bank:read): One offered site in full: the site (domain, DR, traffic), the offering (type, base price, turnaround), the publisher, allowed URLs, monthly quota and how much of it this month used, source, status, visibility, custom name, notes. Your own assets only (403 otherwise). _Inputs: assetId: string (required)._
- **`asset_bank_list`** (asset-bank:read): The pages your account offers to exchange partners (your own sites where a partner's link can go), with quota and status. _Inputs: accountId: string; websiteId: string; clientId: string; scope: enum(account, client); sourceType: enum(client_owned, publisher_offered, network_partnership); status: string; visibility: enum(public, private, account_only); availableOnly: boolean; limit: integer; offset: integer._
- **`asset_bank_page_urls_add`** (asset-bank:write): Add a page URL to an offered site's list with status 'recommended' | 'available' | 'excluded' and optional notes. Your own assets only. confirm false previews; confirm true writes. _Inputs: assetId: string (required); pageUrl: string (required); status: enum(recommended, available, excluded) (required); notes: string; confirm: boolean._
- **`asset_bank_page_urls_delete`** (asset-bank:write): Remove one page URL from an offered site's list. Your own assets only. confirm false previews; confirm true writes. _Inputs: assetId: string (required); pageUrlId: string (required); confirm: boolean._
- **`asset_bank_page_urls_list`** (asset-bank:read): The page URLs configured on an offered site (the pages a link insertion may land on, or recommended pages for guest posts), each with status 'recommended' | 'available' | 'excluded' and notes, sorted recommended, available, excluded. Your own assets only. _Inputs: assetId: string (required)._
- **`asset_bank_page_urls_update`** (asset-bank:write): Change a page URL on an offered site: its status, notes or the URL itself. Your own assets only. confirm false previews; confirm true writes. _Inputs: assetId: string (required); pageUrlId: string (required); pageUrl: string; status: enum(recommended, available, excluded); notes: string; confirm: boolean._
- **`asset_bank_update`** (asset-bank:write): Change an offered site's name, allowed URLs, monthly quota, visibility or status. Confirm true writes. _Inputs: assetId: string (required); customName: string; allowedUrls: array<string>; monthlyQuota: integer | null; visibility: enum(public, private, account_only); status: string; notes: string; clientId: string | null; confirm: boolean._
- **`client_exchange_inventory_summary`** (asset-bank:read): What a brand can offer exchange partners: link spots on its own pages, mentions in articles being written for other sites, and its marketplace page. _Inputs: clientId: string (required)._
- **`collab_opportunities`** (collaborative-placements:read): Articles being written for other sites that accept added brands, across orders: per opportunity the site, topic and keyword, the prices for a link and for a mention only (cents), total / filled / available spots, whether it still accepts collaborators, writing progress, tags and a pitch summary. Filters: status 'enabled' | 'disabled' | 'all', tags (comma-separated; tagsMatchAll for AND), hasAvailableSpots. _Inputs: status: enum(enabled, disabled, all); tags: string; tagsMatchAll: boolean; hasAvailableSpots: boolean._
- **`collab_order_summary`** (collaborative-placements:read): A compact view of the collaborations on one order: counts of collaborative and standalone articles, whether every collaborator has paid, the related orders (account, state, paid, item count) and per article the site and its collaborator count. Prices, anchors, dates and per-participant detail are in collab_participants. _Inputs: orderId: string (required)._
- **`exchange_cadence_audit`** (opportunities:read): Pre-flight for the exchange follow-up cadence on one opportunity: what is due, what is blocked and why. _Inputs: opportunityId: string (required)._
- **`exchange_get`** (opportunities:read): One exchange in full: the parties, what each gives and gets, its status and the conversation. _Inputs: exchangeId: string (required)._
- **`exchange_participant_set_status`** (opportunities:write): Accept or decline an exchange invitation you received. Confirm true writes. _Inputs: exchangeId: string (required); participantId: string (required); action: enum(accept, decline) (required); reason: string; confirm: boolean = false._
- **`exchange_reply_batch_send`** (opportunities:write): Sends the prepared exchange replies for one approval batch. Each send is a write. _Inputs: batchId: string (required); decisions: array<object { opportunityId: string; action: enum(send, skip); subjectOverride?: string; bodyOverride?: string; acceptAdvisory?: boolean }>; acceptAdvisory: boolean; confirm: boolean = false._
- **`exchange_reply_draft`** (opportunities:read): The reply exchange_reply_send would send for an opportunity: subject, body, threading headers and the idempotency key. A pure read, nothing is sent or stored. Returns 400 when a hard prerequisite is missing (contact email, sending mailbox, conversation); exchange_reply_prep names the gap. _Inputs: opportunityId: string (required); subjectOverride: string; bodyOverride: string._
- **`exchange_reply_prep`** (opportunities:write): Readiness check before replying on an exchange: the thread state, the partner facts and what the reply must cover. _Inputs: opportunityId: string (required)._
- **`exchange_reply_send`** (opportunities:write): Send a threaded reply on an exchange opportunity by email: a real message to a real contact, irreversible. With confirm false or omitted it returns the draft (same as exchange_reply_draft). Refused with 400 while exchange_reply_prep lists a blocking item, or an advisory item without acceptAdvisory true. Idempotent on (opportunity, body, inReplyTo): the same content again returns the existing message id without sending twice. _Inputs: opportunityId: string (required); subjectOverride: string; bodyOverride: string; acceptAdvisory: boolean; confirm: boolean = false._
- **`opportunity_accept_collab`** (opportunities:write): Accept a partner's request for a mention in one of your articles or a link on one of your offered pages. confirm false previews what would be created; confirm true writes. _Inputs: opportunityId: string (required); confirm: boolean = false; spotOverride: integer._
- **`opportunity_accept_exchange`** (opportunities:write): Accept a request from your exchange page: creates your side (the link you get) and the partner's side (the link you give) in one step. Confirm true writes. _Inputs: opportunityId: string (required); orderId: string; domainTargets: array<object { domain?: string; targetUrl?: string; targetPageId?: string; anchorText?: string; clientId?: string; offeringType?: string; publisherInsertionUrl?: string }>; confirm: boolean = false._
- **`opportunity_batch_summary`** (opportunities:read): One card per batch of your opportunities: counts by status, discovery candidates by status, first-touch messages sent / replied / won, and the last activity. Pass clientId for one brand or batchKey for one batch. _Inputs: clientId: string; batchKey: string._
- **`opportunity_candidate_add`** (opportunities:write): Add a contact you know for an opportunity's site. _Inputs: opportunityId: string (required); candidateKind: enum(publisher, shadow_publisher, acquisition_identity, research) (required); candidateLabel: string (required); candidateRef: string; candidateEmail: string; discoveryScore: integer; source: string; sourceSignal: object._
- **`opportunity_candidate_delete`** (opportunities:write): Archive a contact on an opportunity (kept for the record, hidden from the list). _Inputs: opportunityId: string (required); candidateKey: string (required)._
- **`opportunity_candidate_list`** (opportunities:read): Alternative contacts found for an opportunity (who else at the site could answer), with status. _Inputs: opportunityId: string (required)._
- **`opportunity_candidate_scan`** (opportunities:write): Look for alternative contacts for an opportunity's site; persist true saves them. _Inputs: opportunityId: string (required); persist: boolean._
- **`opportunity_candidate_update`** (opportunities:write): Change a contact's status or details on an opportunity. _Inputs: opportunityId: string (required); candidateKey: string (required); status: enum(discovered, feeler_sent, replied, declined, won, archived); lastFeelerSentAt: string | null; lastFeelerChannel: enum(slack, email) | null; candidateLabel: string; candidateEmail: string._
- **`opportunity_conversation_post`** (opportunities:write): Reply on an opportunity's conversation; the message is emailed to the other party. confirm true sends; without it the draft is returned. _Inputs: opportunityId: string (required); content: string (required); subject: string; conversationId: string; internalOnly: boolean; dryRun: boolean; confirm: boolean = false._
- **`opportunity_conversation_read`** (opportunities:read): The conversation of an opportunity (opportunityId; add conversationId for one of its side threads, the same pair opportunity_conversation_post takes) or of one exchange thread (exchangeId + conversationId, as exchange_get lists them), never opportunityId with exchangeId: the conversation record (status, last message at) and its messages with sender, body, channel, sent at and threading data. Your own only. opportunity_conversation_post and exchange_conversation_post write to them. _Inputs: opportunityId: string; exchangeId: string; conversationId: string._
- **`opportunity_decline`** (opportunities:write): Decline a partner request. _Inputs: opportunityId: string (required); reason: string; confirm: boolean = false._
- **`opportunity_feeler_send`** (opportunities:write): Sends a first-touch message to a contact found for an opportunity: a real email to a real person, in the account's name. _Inputs: opportunityId: string (required); candidateKey: string (required); messageText: string (required); templateTier: enum(T1_no_email, T2_with_email, followup, manual); templateVersion: string; dryRun: boolean; subject: string; purpose: enum(restore_chase)._
- **`opportunity_get`** (opportunities:read): One opportunity (a partner or publisher interaction) in full: who, which site, which target page, status, the conversation. view 'replies' lists their replies. _Inputs: opportunityId: string (required); view: enum(default, replies); includeAssignmentForm: boolean; accountSearch: string; includeClientBatches: boolean._
- **`opportunity_lifecycle`** (opportunities:read): Everything about one opportunity in one call: workflow, exchange, picks, token, thread, approvals, and a one-line state. _Inputs: opportunityId: string (required)._
- **`opportunity_list`** (opportunities:read): Your opportunities (partner and publisher interactions) with filters: status, brand, search, batch. Counts by status. _Inputs: status: string; clientId: string; accountId: string; publisherId: string; sourceFilter: string; search: string; approval: string; batchKey: string; intent: enum(li_bump_refresh, li_paid, gp_availability, cold_outreach, casework_blast, exchange, other); page: integer; limit: integer._
- **`opportunity_osg_enqueue`** (opportunities:write): The background form of opportunity_osg_run: mode 'enqueue' queues a run (status 'cached', 'no_cache' or 'queued' with a runId; bypassCache and cacheOnly change the cache behaviour), mode 'poll' with runId returns its status and timings. Linkio staff only; an account call returns 403. _Inputs: mode: enum(enqueue, poll); runId: string; partnerUrls: array<string>; minDR: number; priceCapCents: number; limit: integer; model: string; exchangeContext: string; includePromotedSingles: boolean; bypassCache: boolean; cacheOnly: boolean; clientContext: object { brandName?: string; targetUrl?: string; anchor?: string }._
- **`opportunity_osg_pin`** (opportunities:write): The offer shortlist pinned to an opportunity's active exchange-offer token, which is what the partner sees on the share page: mode 'read' returns it with its history; mode 'write' with picks (primary, backups, verdictNote) and confirm true replaces it and records the change. Linkio staff only; an account call returns 403. _Inputs: mode: enum(read, write); opportunityId: string (required); picks: object; source: string; confirm: boolean._
- **`opportunity_osg_run`** (opportunities:write): Offer suggestions for a partner from 1-20 of their pages, in one synchronous call (about 60 seconds): keyword extraction, marketplace search (minDR default 40, priceCapCents default 6000, limit default 50), scoring and a verdict. Linkio staff only; an account call returns 403. _Inputs: partnerUrls: array<string> (required); opportunityId: string; clientId: string | null; minDR: number; priceCapCents: number; limit: integer; model: string; exchangeContext: string; includePromotedSingles: boolean; clientContext: object { brandName?: string; targetUrl?: string; anchor?: string; clientName?: string | null; anchorText?: string }._
- **`opportunity_page_get`** (opportunities:read): One exchange page's full settings: which of your sites it offers, how partners are matched, the marketplace rules, privacy. _Inputs: pageId: string (required)._
- **`opportunity_page_list`** (opportunities:read): Your exchange pages (the partner-facing pages where others request links from you) with their settings and visit counts.
- **`opportunity_page_update`** (opportunities:write): Change your exchange page: title, privacy, whether collaborations and offered sites are on, notifications. Confirm true writes. _Inputs: pageId: string (required); pageTitle: string; privacyMode: boolean; privacyDescription: string; collabEnabled: boolean; assetBankEnabled: boolean; notificationConfig: object { notifyInternal?: boolean; notifyPageOwner?: boolean; notifyPartner?: boolean }; assetBankIds: array<string>; collabSelectionMode: enum(all, by_tags, by_account, by_accounts, manual); collabTagsFilter: array<string>; collabAccountFilter: string; collabClientFilter: string; collabAccountFilters: array<object { account_id: string; client_id: string | null }>; collabManualIds: array<string>; exchangeRequirements: object; internalName: string; expiresInDays: integer; marketplaceEnabled: boolean; marketplacePriceCapCents: integer | null; marketplaceMinDr: integer | null; marketplaceNiches: array<string> | null; marketplaceMaxSelections: integer | null; confirm: boolean._
- **`opportunity_picker_history`** (opportunities:read): The last 20 unexpired picker runs for a brand + publisher site pair, each with its stored full result. Linkio staff only; an account call returns 403. _Inputs: clientId: string (required); publisherDomain: string (required)._
- **`opportunity_picker_record_anchor`** (opportunities:write): Record the final anchor text of an exchange item or order item after a page pick (one of lineItemId or exchangeItemId, with clientId, anchorText up to 500 characters, source 'dropdown' | 'ai-generated' | 'manual-typed'); confirm true writes, otherwise a dry run. Linkio staff only; an account call returns 403. _Inputs: lineItemId: string; exchangeItemId: string; clientId: string (required); anchorText: string (required); source: enum(dropdown, ai-generated, manual-typed); opportunityId: string; confirm: boolean._
- **`opportunity_picker_record_pick`** (opportunities:write): Records the page chosen for an item after a picker run. _Inputs: lineItemId: string; exchangeItemId: string; clientId: string (required); publisherDomain: string (required); pick: object { publisherUrl: string; recommendedTargetUrl: string; recommendedTargetPageId: string; rank: integer; confidence: number; reasoning: string; pageFormat: string; runId: string } (required); pickSource: enum(primitive, manual); opportunityId: string; confirm: boolean._
- **`opportunity_picker_run`** (opportunities:write): Ranks a publisher site's pages for a brand's target pages, so a link lands on the page that fits best. _Inputs: publisherDomain: string (required); clientId: string (required); maxCandidates: integer; runVerdicts: boolean; cacheOnly: boolean; includeRejected: boolean; dfsRowLimit: enum(100, 500, 1000); seedUrls: array<string>; hints: object { targetPageIds?: array<string>; prospectingKeywords?: array<string> }; opportunityId: string._
- **`opportunity_submissions_list`** (opportunities:read): The requests that came in through your exchange pages: opportunity_list limited to status 'qualified' and source exchange_page, with the same filters (clientId, search). Your own plus those where you are the publisher. _Inputs: clientId: string; accountId: string; publisherId: string; search: string; page: integer; limit: integer._
- **`opportunity_token_status`** (opportunities:read): The latest exchange-offer token of an opportunity (the link a partner opens): id, value, status, expiresAt, isExpired, daysUntilExpiry and the number of open requests on it; { hasToken: false } when none was issued. Your own opportunities only. _Inputs: opportunityId: string (required)._
- **`opportunity_update`** (opportunities:write): Correct fields on one of your opportunities (contact, notes, status, published URL). _Inputs: opportunityId: string (required); accountId: string; clientId: string; publisherId: string; websiteId: string; offeringId: string; targetPageId: unknown | string | null; anchorText: unknown | string | null; contactEmail: string; contactName: string; sourceType: enum(email, chatwoot, manual, smart_import, prospect_finder, exchange_page, client_direct); sourceReference: string; responseClassification: enum(interested, declined, needs_info, counter, auto_reply); outreachChannel: enum(gmail, maildoso, manyreach, resend); outreachMailbox: unknown | string | null; batchKey: unknown | string | null; intent: unknown | enum(li_bump_refresh, li_paid, gp_availability, cold_outreach, casework_blast, exchange, other) | null; outreachSentAt: string; gmailMessageId: string; gmailThreadId: string; chatwootConversationId: string; chatwootInstance: string; notes: string; status: enum(qualified, assigned, in_progress, completed, failed); publishedUrl: string; requestData: object; submitterName: string; submitterCompany: string; currentPublisherPageUrl: string; metadata: object; approvedBy: string._

## Other

- **`account_api_key_revoke`** (api-keys:write): Revoke one of your account API keys (ids from account_api_keys_list). _Inputs: keyId: string (required)._
- **`account_api_keys_list`** (api-keys:read): Your account API keys: name, prefix, scopes, created, last used, revoked (never the secret), plus the scopes your account type may hold. Keys are created on the API keys page by the account owner, not through the API. Needs client-config:read.
- **`account_llm_tracking_backlinks`** (llm-tracking:read): The same links as account_llm_tracking_summary with the counts behind each provider: how many times each link was checked and how many checks came back cited (the "how often" view; the summary is the yes/no view).
- **`account_llm_tracking_export`** (llm-tracking:read): Your AI citation data as rows ready for a spreadsheet. type 'all' (default): every link with its citation summary, one row per link. type 'citations': the outside domains the AI assistants cite for your keywords, deduplicated, which is a prospecting list for outreach. _Inputs: type: enum(all, citations)._
- **`account_llm_tracking_summary`** (llm-tracking:read): Every published link of your account checked for AI citations, one row per link: whether ChatGPT, Perplexity, Claude and Gemini cited it, whether it came from an order or an import, and when it was last checked. The same data as the AI Mentions page, as JSON. days sets the lookback window (default 30). Your own links only. _Inputs: days: number._
- **`account_seller_policy_get`** (orders:read): Your default seller policy and whether you can change it: which seller is booked when you add a site to an order without choosing one. linkio_default = the verified owner unless a reseller priced at least 15% below the owner is proven on the site at that price; owner_only = verified owners only (a site with no owner falls back to linkio_default and the item says so); proven_only = sellers whose latest paid order on the site cost no more than their price today; cheapest = the lowest price in good standing. _Inputs: accountId: string._
- **`account_seller_policy_set`** (orders:write): Change your default seller policy (linkio_default, owner_only, proven_only or cheapest). Sites added from now on follow it; items already booked keep their seller. A managed account's policy is set by your account manager. _Inputs: policy: enum(linkio_default, owner_only, proven_only, cheapest) (required); accountId: string._
- **`account_waiting_answer`** (orders:write): Answer or close one question waiting on you: pick an option by its number, write your answer, or both; your words are kept exactly as written. Linkio does not act on the answer for you: you answer a seller's request to the seller in the placement's thread. A QA question is answered by a QA pass or fail on the placement. The decision is yours, so your assistant asks you before it answers. Free. _Inputs: taskId: string (required); action: enum(answer, close); optionIndex: integer; text: string._
- **`account_waiting_list`** (orders:read): The questions waiting on you now about your self-serve placements: a seller asks for a higher price, a content change or an advance payment, or the automatic QA check could not decide. Each has the question, its options and how it is answered (here, or by a QA pass or fail on the placement). Free. _Inputs: includeClosed: boolean; accountId: string._
- **`agent_report_get`** (agent-reports:read): One report made for your brand (keyword research): its sections, the decisions on its items, and its comments. Only the reports made for your account. Free. _Inputs: reportId: string (required)._
- **`agents_activity`** (agents:read): What one agent did, newest first: its runs, the items it worked (with the outcome it reported, final state and next check), wake-ups, conversations, and each action it took. _Inputs: agent: string (required); limit: integer; before: string._
- **`agents_answer`** (agents:answer): Answers an agent's question as the person: option \ _Inputs: conversation_id: string (required); turn_id: string (required); index: integer (required); note: string; source_ref: string._
- **`agents_close_checked`** (agents:answer): Closes, as the person: - task_ids: questions the desk found stale or already resolved (from agents_desk_checked). _Inputs: task_ids: array<string>; conversation_ids: array<string>; reason: string._
- **`agents_conversation`** (agents:read): One agent conversation in full: every message both ways (oldest first), the tasks it covers, and which buttons still work (turns with live=true). _Inputs: conversation_id: string (required)._
- **`agents_conversations`** (agents:read): List agent conversations, one per (person, item), newest first. _Inputs: view: enum(needs_you, mine, all); q: string; account: string; limit: integer._
- **`agents_desk_checked`** (agents:read): Open questions waiting on the caller that the desk agent checked and found stale or already resolved, each with the desk's reason.
- **`agents_hand_over`** (agents:answer): Hands your conversation to a teammate (staff): "not mine, ask Felix". _Inputs: conversation_id: string (required); to: string (required); why: string._
- **`agents_list`** (agents:read): The agents and how healthy they are: last run, runs and failures (7 days), questions waiting on people, answer rate and median time to answer (30 days), failed wake-ups, plus the Claude logins they run on. _Inputs: account: string._
- **`agents_needs_me`** (agents:read): What the agents wait on the caller for: open questions, proposals to confirm, agent messages with no reply yet. _Inputs: limit: integer; order: enum(recent, oldest); compact: boolean._
- **`agents_reply`** (agents:answer): Writes in a conversation as the person: the text is what the person says to the agent. _Inputs: conversation_id: string (required); text: string (required)._
- **`agents_take`** (agents:answer): Takes over a teammate's conversation (staff): it moves to the caller, a note in the thread says who took it from whom, and from then on the caller answers it as themselves. _Inputs: conversation_id: string (required); reopen_audited: boolean._
- **`brand_brief_get`** (topic-gen:read): Your brand's saved brand brief: the text every article for this brand is written from (finalBrief), when it was last saved (lastUpdated) and its status. finalBrief is null when no brief is saved yet. homepage does not apply to your account. Free. _Inputs: clientId: string (required); homepage: boolean._
- **`brand_brief_save`** (topic-gen:write): Save your brand's brand brief. text is the whole brief as it should be saved (what the company is, facts writers may use, facts they must not write, what sets the brand apart, the brand-name forms to use; up to 50,000 characters). It replaces the saved brief, and every new article for this brand is written from it. fromDraft and why do not apply to your account. Free. _Inputs: clientId: string (required); fromDraft: boolean; text: string; why: string; accountRoute: boolean._
- **`campaign_classify_get`** (campaign:read): The classification results of a campaign: status, the summary counts (classified, skipped, pending, failed), the scope (domains excluded by failed metrics), the distributions (relationship, domain type, page type, vertical) and a paginated list of domains with their verdicts. Filters: relationship, domainType, search, sort, dir, limit, offset. Costs nothing. _Inputs: campaignId: string (required); relationship: string; domainType: string; search: string; sort: enum(niche_proximity, domain, dr, traffic); dir: enum(asc, desc); limit: number; offset: number._
- **`campaign_classify_reset`** (campaign:write): Clear the classification of a campaign's domains (relevance, vertical, status) so the next campaign_classify_start runs fresh; the cached domain types are kept. Costs nothing. Refused (409) while a classification of the campaign is still running. _Inputs: campaignId: string (required)._
- **`campaign_classify_start`** (campaign:write): Classify a campaign's domains with three AI layers (domain type, page type, relevance to your brand) so you can route them into campaign types. With confirm false it answers the quote and starts nothing. With confirm true it holds the quoted amount (the prospectClassifyCents fee per domain, plus the AI provider's expected price with margin on Linkio's key; the fee only when your own OpenAI key is checked for 'prospect-classify': onOwnKey true) and starts the run in the background; the hold is settled to what the run used when it ends — the fee only for domains that reached a verdict. If your own key fails mid-run, the rest runs on Linkio's key at the platform price when your balance covers it (the run's key_notices name the failure and that switch), else the run stops. 402 when the hold cannot be funded; 409 while a classification of the campaign is still running; 400 DOMAIN_LIMIT above 20,000 domains in one run. A second run classifies only the domains not yet classified. Your run does not start the site metrics check. usage_estimate feature key: 'prospect_classify' (count = domains). _Inputs: campaignId: string (required); batchSize: number; clientContext: string; includeMetricsPending: boolean; confirm: boolean = false._
- **`campaign_classify_status`** (campaign:read): The classification run of a campaign right now: activeRun (phase, layer, batch progress, heartbeat age, stalled) while it runs, else null and lastRun (status, partial, the layer error counts, aborted: budget_exceeded or key_paused, and the keyNotices of a run on your own OpenAI key). Costs nothing. _Inputs: campaignId: string (required)._
- **`campaign_contacts_delete`** (campaign:write): Remove contacts (by id) from one of your campaigns. Only the link between the contact and this campaign is removed; the contact record itself stays and other campaigns keep it. Costs nothing. _Inputs: campaignId: string (required); contactIds: array<string> (required)._
- **`campaign_contacts_discover`** (campaign:write): Find contacts at the domains a campaign type assigned in one of your campaigns (mode new = domains never tried, empty = domains tried before with nothing found). Paid: dryRun true answers the quote and starts nothing; without confirm true the answer is the quote with needsConfirm: true and nothing is held; confirm true holds the quoted amount and starts the run as a child campaign of yours, settled to what it used (the per-domain fee plus the providers' price with margin, or the fee alone on your own keys; the search step runs only on your own Hunter key). workflowName and targetVerified are ignored for your account (the one account recipe runs). 402 when the hold cannot be funded; 400 DOMAIN_LIMIT above 5,000 domains. _Inputs: campaignId: string (required); campaignTypeId: string (required); workflowName: enum(quickenrich-only, findymail-quickenrich-verification, findymail-verification, findymail-broad, findymail-then-ai-scrape, ai-scrape-only, workflow4-hunter-findymail, workflow4-hunter-findymail-verification); targetVerified: number; mode: enum(new, empty); dryRun: boolean; confirm: boolean._
- **`campaign_contacts_import_csv`** (campaign:write): Import a contacts CSV (an Apollo export: columns Email, Company Name, Company Website, Company Domain, plus the optional name, title and LinkedIn columns) into one of your prospecting campaigns. Free: no provider is called and nothing is charged or held. Only rows whose company domain is one of the campaign's domains are stored, as unverified contacts; the answer gives rowsKept, rowsDropped, up to 20 droppedDomains and the contactIds. A campaign with no domains answers 400 NO_CAMPAIGN_DOMAINS; at most 5,000 rows per import (400 ROW_LIMIT). With dryRun true it counts and stores nothing. The paid next step is campaign_contacts_verify with those contactIds. _Inputs: campaignId: string (required); csv: string (required); dryRun: boolean._
- **`campaign_contacts_verify`** (campaign:write): Verify a campaign's contacts (the ones you name by id): dryRun true answers the quote and starts nothing; without confirm true the answer is the quote with needsConfirm: true and nothing is held; confirm true holds the quoted amount and starts the run, settled to what it used (the per-contact fee plus the providers' price with margin, or the fee alone on your own keys). 402 when the hold cannot be funded; 409 while a verification of the campaign is already running. At most 1,000 contact ids per call. _Inputs: campaignId: string (required); contactIds: array<string> (required); dryRun: boolean; confirm: boolean._
- **`campaign_contacts_verify_estimate`** (campaign:read): The price of verifying a number of a campaign's contacts (the amount campaign_contacts_verify would hold): the per-contact fee plus the email verification providers' expected price with margin, or the fee alone on your own keys. Costs nothing. _Inputs: campaignId: string (required); contactCount: integer (required)._
- **`campaign_discovery_results`** (campaign:read): The AI discovery results of one of your campaigns, grouped by domain: per domain the workflow type, the result, its status and error; per workflow type the counts (success, error, qualified, rejected) and an error breakdown. Costs nothing. _Inputs: campaignId: string (required)._
- **`campaign_domain_list_rejected`** (campaign:read): The rejected domains of one of your campaigns with their reasons, paged (limit, offset) and filterable by reason. Costs nothing. _Inputs: campaignId: string (required); limit: number; offset: number; reason: string._
- **`campaign_enhancements_config_update`** (campaign:write): Set a campaign type's positioning_intent for your campaign (stored per campaign on the type's ranking row; 409 rankings_row_not_found when the type is not ranked in the campaign yet) and, for a type of your own brand, its rules.enhancements (the page-check settings: allowed_fits, allowed_buckets, required). A shared type's rules are Linkio's and cannot be changed from an account: 422 cannot_configure_shared_type. Starts no run: the next campaign_enhancements_run uses the new settings. Costs nothing. _Inputs: campaignId: string (required); typeId: string (required); positioning_intent: string | null; enhancements: object._
- **`campaign_enhancements_list`** (campaign:read): The page checks of one campaign type: the enabled checks, each run's state (a run stopped at its hold shows budget_stopped: true and a message), and the verdict per page. With list true, or with no typeId at all, it answers the campaign's types instead. Costs nothing. _Inputs: campaignId: string (required); typeId: string; list: boolean._
- **`campaign_enhancements_override`** (campaign:write): Set your own verdict on one page of a campaign type (topical_fit or content_validation); for content_validation, a null value clears your override and restores the AI verdict. Costs nothing. _Inputs: campaignId: string (required); typeId: string (required); slug: enum(topical_fit, content_validation) (required); urlCanonical: string (required); overrideValue: string | null (required); reason: string._
- **`campaign_enhancements_preflight`** (campaign:write): Check a campaign type's page-check setup without starting a run: it reports what would block the start (for example a missing positioning intent) and how to fix it. Costs nothing. _Inputs: campaignId: string (required); typeId: string (required)._
- **`campaign_enhancements_rejections_clear`** (campaign:write): Clear one domain rejection of your campaign (by rejectionId from campaign_enhancements_rejections_list) with an optional reason: the row keeps the audit trail and the domain is eligible for the type again on the next campaign_enhancements_rerun_assignments. 404 when the rejection is not in this campaign or was cleared already. Costs nothing. _Inputs: campaignId: string (required); rejectionId: string (required); reason: string._
- **`campaign_enhancements_rejections_list`** (campaign:read): The domains a page check rejected for one campaign type of your campaign (every page on the domain failed a required check): domain, reason, the rejecting check, a sample URL, when; includeCleared adds the ones cleared since. Costs nothing. _Inputs: campaignId: string (required); typeId: string (required); includeCleared: boolean._
- **`campaign_enhancements_rerun_assignments`** (campaign:write): Recompute the campaign type assignments of your campaign after page-check runs or cleared rejections: the existing assignments are deleted and the priority claim loop runs again, so a domain rejected from one type flows to the next matching type. Every active type must be ranked. Answers deleted, assigned, by_type, before and after counts. Costs nothing. _Inputs: campaignId: string (required)._
- **`campaign_enhancements_run`** (campaign:write): Run the page checks of a campaign type: topical fit (an AI verdict per page) and, when the type enables it, content validation (the page is fetched and judged). With dryRun true it answers the price and starts nothing. With confirm true it holds the quoted amount (the prospectEnhanceUrlCents fee per page, plus the AI provider's expected price with margin on Linkio's keys for topical fit — not charged when your own OpenAI key is checked for 'prospect-enhance' (onOwnKey true) — and 0.1c per fetch that returned a page for content validation) and starts the run in the background; the hold is settled to what the run used when it ends — the fee once per page that got a verdict. If your own key fails mid-run, the rest runs on Linkio's key at the platform price when your balance covers it (the run's keyNotices name the failure and that switch), else the run stops. The run never spends past its hold: when the hold is used up it stops (budget_stopped: true); start again to check the remaining pages. With neither flag nothing starts: the answer is the quote with needsConfirm true. 402 when the hold cannot be funded; 409 while a run of the same campaign type is in flight; 400 NO_PAGES when there is nothing to check; 400 URL_LIMIT above 2,000 pages in one run. usage_estimate feature key: 'prospect_enhance' (count = pages). _Inputs: campaignId: string (required); typeId: string (required); mode: enum(inline, trigger); dryRun: boolean; confirm: boolean._
- **`campaign_export_classification`** (campaign:read): The campaign's classification verdicts as CSV text: domain, domain type, page types, relevance, vertical, niche proximity, status, reason. Read only; costs nothing. The answer carries the CSV text (csv), the headers, rowCount and truncated (true past 10,000 rows). _Inputs: campaignId: string (required)._
- **`campaign_export_outreach_drafts`** (campaign:read): The campaign's outreach drafts as CSV text: contact, email, domain, round, step, delay days, subject, body, status — every round, or one with roundId. Read only; costs nothing. The answer carries the CSV text (csv), the headers, rowCount and truncated (true past 10,000 rows). _Inputs: campaignId: string (required); roundId: string._
- **`campaign_export_outreach_template`** (campaign:read): The outreach template and follow-up sequence of the campaign's rounds: per round the composed subject and body (with their variables) and the sequence steps (step, type, delay days), as JSON (rounds) and as CSV text. Read only; costs nothing. The answer carries the CSV text (csv), the headers, rowCount and truncated (true past 10,000 rows). _Inputs: campaignId: string (required); roundId: string._
- **`campaign_export_rejected_domains`** (campaign:read): The campaign's rejected domains as CSV text: domain, source (the domain filters or a campaign type's page checks), campaign type, reason, when. Read only; costs nothing. The answer carries the CSV text (csv), the headers, rowCount and truncated (true past 10,000 rows). _Inputs: campaignId: string (required)._
- **`campaign_export_serp_results`** (campaign:read): The campaign's SERP results as CSV text: domain, keyword, position, url, title (one row per result page). Read only; costs nothing. The answer carries the CSV text (csv), the headers, rowCount and truncated (true past 10,000 rows). _Inputs: campaignId: string (required)._
- **`campaign_export_type_matches`** (campaign:read): The campaign-type matches as CSV text: campaign type, rank, domain, matched page count, matched pages. A match is a rule match; no score is stored. Read only; costs nothing. The answer carries the CSV text (csv), the headers, rowCount and truncated (true past 10,000 rows). _Inputs: campaignId: string (required)._
- **`campaign_inventory_list`** (campaign:read): The sites in Linkio's network among a campaign's SERP results, as recorded by the campaign's last prospect_inventory_crossref (the network match): per domain or per page the source (paid site or exchange partner), DR, traffic, whether you already have a link there and its top keywords, paged and filterable (view, source, search, page, limit). Prices, publisher names and contact details are not shown here. Costs nothing. _Inputs: campaignId: string (required); view: enum(domains, pages); source: enum(paid, exchange); search: string; page: number; limit: number._
- **`campaign_serp_aggregated`** (campaign:read): Which domains appear across the completed SERP searches of a campaign: best position, how many keywords each ranks for, sample keywords and URLs. Domains that keep appearing are the strongest prospects. _Inputs: campaignId: string (required)._
- **`campaign_serp_search_create`** (campaign:write): Prepare a SERP search on a campaign: the keywords, optional locations, and results per query (10, 20, 50 or 100). Nothing runs. The answer carries searchId, totalQueries and estimatedCostCents, the amount campaign_serp_search_run would hold. usage_estimate feature key: 'serp_search' (count = queries). _Inputs: campaignId: string (required); keywords: array<string> (required); locations: array<string>; resultsPerQuery: number._
- **`campaign_serp_search_list`** (campaign:read): The SERP searches of one of your campaigns (the last 20): keywords, depth, status, query and result counts, dates. Costs nothing. _Inputs: campaignId: string (required)._
- **`campaign_serp_search_run`** (campaign:write): Run a prepared SERP search: Google results for every query, in the background. With confirm false it answers the quote and starts nothing. With confirm true it holds the quoted amount (the serpSearchCents fee per query, plus the search provider's price with margin when Linkio's login serves the scan; the fee alone on your own DataForSEO key) and starts the scan; the hold settles to what the scan used when it ends. campaign_serp_search_status reports progress. _Inputs: campaignId: string (required); searchId: string (required); confirm: boolean = false._
- **`campaign_serp_search_status`** (campaign:read): Where a SERP search is: pending, running, completed or failed, with queries completed and failed, results and unique domains found, the amount charged when it ended, and a message when your own DataForSEO key failed during the scan. Returns the search with its results. _Inputs: campaignId: string (required); searchId: string (required)._
- **`campaign_type_assign`** (campaign:write): Assign one of your campaign's ranked types to the domains that match its rules (the type must be in the campaign's rankings; rank it first). Costs nothing. _Inputs: campaignId: string (required); campaignTypeId: string (required)._
- **`campaign_type_list`** (campaign:read): The campaign types available to one of your campaigns — Linkio's predefined shared types and your brand's own types — with the match count of each against the campaign's domains. Costs nothing. _Inputs: campaignId: string (required)._
- **`campaign_type_rankings_get`** (campaign:read): The ranked order of campaign types on one of your campaigns, with each type's positioning text. Costs nothing. _Inputs: campaignId: string (required)._
- **`client_geo_strategy`** (client-config:write): A brand's topical distribution plan, bound to its active link plan: categories on up to three axes (head-term variants; audience or context modifiers; an optional third), each with name, targetPercentage, matchingTerms, color, sortOrder and axisLabel, plan-wide or per target page. action 'get' (default) reads; 'upsert' saves a set of categories as a diff-merge; 'delete-one' removes one by id; 'delete-scope' empties one axis for one page; 'promote-to-plan' moves older brand-wide categories into the active plan. Writes need an active link plan (otherwise NO_ACTIVE_PLAN); planId is resolved automatically. dryRun true previews a write. _Inputs: action: enum(get, upsert, delete-one, delete-scope, promote-to-plan) = "get"; clientId: string (required); axis: enum(primary, secondary, tertiary); targetPageId: string; categories: array<object { id?: string; name: string; targetPercentage?: number | null; matchingTerms?: array<string>; description?: string | null; color?: string | null; sortOrder?: integer }>; axisLabel: string; categoryId: string; dryRun: boolean = false._
- **`client_target_page_coverage`** (client-config:read): Link coverage per target page of a brand: delivered links (site, anchor, month, order), pre-platform history (site, anchor, DR, traffic), the pipeline (site, anchor, publisher status), the page's link count (shown as not loaded, with the reason: no per-page Ahrefs Best-links read exists, and a DataForSEO count is never given as the link count), enrichment flags and each page's share of all links, plus a summary (pages with links, pages with none, totals). months (default 3) sets how much delivery history is included; includeInactive adds inactive and completed pages. Free. _Inputs: clientId: string (required); months: number; includeInactive: boolean._
- **`doc_sharing`** (workflows:write): Who can open your article's Google Doc. action get: its permissions, the link role (anyoneWithLink) and publicAccess (whether it opens without a Google sign-in, as a publisher's browser does). action set with mode open: anyone with the link can open it, as reader by default, as writer with role writer (for a publisher who must edit). mode restrict: the link and every person or domain share are removed. set needs a reason (8+ characters) and changes only a doc that Linkio made for that workflow; each change is recorded with the permissions before and after. Inputs: workflowId or lineItemId of your placement, googleDocId (optional, an earlier doc of the same workflow). _Inputs: action: enum(get, set) (required); workflowId: string; lineItemId: string; googleDocId: string; mode: enum(open, restrict); role: enum(reader, writer); reason: string._
- **`docs_page_get`** (any key): Read Linkio's public docs: one page by slug ("self-serve/money" for https://www.linkio.com/docs/self-serve/money; "home" for /docs) as markdown with its link, or with no slug the list of pages. The same text as the docs site. Free. _Inputs: slug: string; onlySlugs: array<string>._
- **`prospect_campaign_create`** (prospect-pipeline:write): Open a keyword prospecting campaign for one of your brands: the container for SERP searches and the domains they find. Takes name, clientId, clientName, clientDomain (the brand's id, name and website from client_search — your account's brands) and optional keywords to store; with campaignType serp_prospecting (the default) the campaign is free to create: nothing runs and nothing is charged until a search is created and run. With dryRun true in either mode nothing is created: a serp_prospecting dry run answers wouldCreate (name, campaignType, clientId) at 0c. A contact-discovery campaign (campaignType contact_discovery with a domains list, at most 5,000) finds and verifies contacts with Linkio's providers, each on Linkio's key or on your own key for that provider when it is on file and checked (then only the fee applies for that provider); the search step runs only on your own Hunter key (fee only; a domain the finder has nothing for ends with no contact and pays no fee); a catch-all address is re-checked only on your own Instantly key, else it stays catch-all: with dryRun true it answers the price and creates nothing; it starts only with confirm: true (with neither flag the answer is the quote with needsConfirm true), and the quote (prospectDomainCents per domain plus the price of the providers on Linkio's keys with margin) is held when it starts and settled to what the run used when it ends. Returns campaignId. _Inputs: name: string (required); clientId: string (required); clientName: string (required); clientDomain: string (required); keywords: array<string>; categories: array<string>; campaignType: enum(serp_prospecting, contact_discovery); serpDepth: number; domains: array<string>; dryRun: boolean; confirm: boolean._
- **`prospect_campaign_get`** (prospect-pipeline:read): One of your campaigns in full: the campaign row, its domains, and its contacts (verified and unverified). account_spend_cents is what your ledger holds for the campaign when you paid for a run. Costs nothing. _Inputs: campaignId: string (required)._
- **`prospect_campaign_list`** (prospect-pipeline:read): Your prospecting campaigns: id, name, status, type, counts (domains, contacts found, verified, delivered), SERP totals, network matches and dates. Campaigns Linkio's team ran for you show no charge; a campaign you paid for shows account_spend_cents, the cents on your ledger for it. Costs nothing. _Inputs: idPrefix: string._
- **`prospect_campaign_update`** (prospect-pipeline:write): Rename one of your campaigns, or move it to another of your brands (clientId with clientName and clientDomain). Costs nothing. _Inputs: campaignId: string (required); name: string; clientId: string; clientName: string; clientDomain: string; accountId: string._
- **`prospect_domains_import`** (campaign:write): Add your own list of domains to one of your campaigns (each as a string or { domain, domainRating?, sourceUrl?, ... }), under a competitorDomain that names where the list came from. The domains join the campaign like discovered ones, so classification, network matching and contact discovery can run on them. At most 5,000 domains per call. A SERP campaign with no scan results becomes a contact-discovery campaign. Costs nothing. _Inputs: campaignId: string (required); domains: array<string | object { domain: string; domainRating?: number; sourceUrl?: string; sourceAnchor?: string; isDofollow?: boolean; linkType?: string; spamScore?: number }> (required); competitorDomain: string; sourceLabel: string; dr: number; organicTraffic: number._
- **`prospect_inventory_crossref`** (prospect-pipeline:write): Match the domains a campaign's SERP searches found against the sites you can buy through Linkio or offer in a link exchange. Returns the matches with source, DR, traffic, publisher name and trust, and whether you already have a link from the site; the match list is saved on the campaign. Needs completed SERP searches. A site that sells links only for a set time (such as 12 months) is left out; includeTimeLimited is for Linkio staff, and an account key always gets the default. _Inputs: campaignId: string (required); includeTimeLimited: boolean._
- **`subscription_cancel`** (billing:write): Cancel a subscription at the end of its current period (action 'cancel'), or undo a pending cancellation (action 'undo'). _Inputs: subscriptionId: string (required); action: enum(cancel, undo) = "cancel"._
- **`subscription_credit_refill`** (billing:write): Automatic credit top-up on a subscription: action 'get' reads it, 'set' turns it on with amount (whole dollars, 10 to 10000), 'remove' turns it off. _Inputs: subscriptionId: string (required); action: enum(get, set, remove) (required); amount: integer._
- **`subscription_customer_portal`** (billing:write): A Stripe customer-portal link where the account owner manages a subscription's payment method and invoices. The link expires. Needs billing:write.
