Every operation

    Every operation of the Fly Agents API, as GET /v1/ops lists it: its agent, read or write, what it does and its params. Each name opens its row on its agent's page.

    Operations

    Run one with POST /v1/locations/{location_id}/ops/{op}, its params as the JSON body. Getting started shows how.

    All 400 operations.

    Operations
    OperationAgentKindWhat it doesParams
    ads_account_billing_doneAds AgentWriteMark billing as set up on one ad account, so the Ads Agent stops asking for it and closes its Set up billing card.{ ads_account_id }
    ads_account_holdAds AgentWriteHold one ad account so the Ads Agent plans and changes nothing on it (hold true), or start it again (hold false), as the start card's Hold this account and the account card's Start again do.{ ads_account_id, hold: boolean }
    ads_account_management_setAds AgentWriteSet an ad account to Fly runs it, Fly recommends (Fly reads and recommends, changes nothing) or Reference only (read for reference, no plan needed), with an optional label.{ ads_account_id, management: managed | advise | read_only, owner_label? }
    ads_accounts_listAds AgentReadThe place's ad accounts, each with its mode (Fly runs it, Fly recommends, Reference only), its label and its ads manager link.{}
    ads_ad_comment_addAds AgentWritePost on a campaign's thread (signed in): a comment, or a change asked (kind change_request). A change on a card still waiting becomes its creative ask, so Fly redraws the ad on its next run and answers on the thread; on a running ad Fly draws a new version on a new ad's card. The client may comment, and ask for changes on a proposal, only while the agency lets them.{ campaign_id: string, kind: comment | change_request, body: string, ad_id?: string, design_key?: <card id>:first|second, ads_account_id?: string }
    ads_ad_comments_listAds AgentReadOne campaign's thread: the comments, the changes asked, the approvals and Fly's answers, oldest first, each with who wrote it ("Priya (agency)", "Owner", "Fly") and its day; a live campaign brings the talk on the cards that made it; and each ad's versions ("Version 2 of 3, Nov 03, 2026, after your comment"). campaign_id is the platform's campaign id, or card:<card id> for a proposal or a new creative still on its card.{ campaign_id: string }
    ads_ad_version_useAds AgentWritePut a kept version of an ad back (owner or admin, signed in): on a card still waiting at once; on a running Facebook and Instagram ad on an account Fly runs, Fly makes a new ad with it on its next run (held while the ad set is learning).{ action_id: string, which?: first | second, index: number }
    ads_agent_audiences_listAds AgentReadThe audiences the Ads Agent built at the place from the site visitors and the CRM (site visitors, customers, leads, people like the customers), each with its network, people, last refresh, whether it holds the least its network needs and what it is used for (customers left out, the lookalike's seed, the X campaigns' list, the come back campaign), and the switch that builds them.{}
    ads_attribution_getAds AgentReadWhat each ad network claims against what Google Analytics saw from its paid visits, week by week over the last 28 complete days of each read: the results the network claims (only results on the site), the key events and sessions Analytics saw from its ads, the results Facebook and Instagram counted after a view with no click, the gap and whether the weekly email tells it (30% or more on a network claiming 10 or more), with the reading in words; and whether Google Analytics is connected.{ weeks?: 1..12 }
    ads_audience_getAds AgentReadWho the ads are for: the confirmed audience (null until one is confirmed), each connected network with what it takes (interests, communities, conversations, industries, job functions, seniorities) or why it takes none, and what the owner's instructions set.{}
    ads_audience_proposeAds AgentWriteThe Ads Agent's proposal of who the ads are for (AI, owner or admin): read from the business and the owner's instructions, every word resolved by each network's targeting search (a word none resolves is listed, never kept); only when none is confirmed, or with fresh. With q, network and kind, one targeting search for the owner's own additions.{ fresh?: boolean } | { q, network: metaads | redditads | linkedinads | pinterestads | xads, kind: interests | communities | conversation_keywords | industries | job_functions | seniorities }
    ads_audience_setAds AgentWriteConfirm who the ads are for (owner or admin): the whole audience (a proposal's, or the current one), or edits laid over the confirmed one. New campaigns take it, and the Ads Agent gives it to the running Meta and Reddit ad sets that carry none.{ audience?: { words, buyers, interests, age_min, age_max, gender, languages, networks: { platform: { targeting, own? } }, accounts? }, edits?: { words?, buyers?, interests?, age_min?, age_max?, gender?, languages?, networks?: { platform: { targeting?, own? } | null }, accounts?: { id: { platform, targeting?, own? } | null } } }
    ads_audiences_setting_setAds AgentWriteSwitch "Build audiences from your customers and site visitors" on or off at the place (owner or admin, signed in), and whether the ad leads get a list of their own. Off keeps the lists made and sends nobody more.{ on: boolean, include_leads?: boolean }
    ads_autopilot_setAds AgentWriteSwitch Autopilot on or off for one ad account Fly runs (owner or admin, signed in). On needs the account's plan to carry Autopilot (the Autopilot plan or the Autopilot add-on; refused not_entitled with the Billing path to add it) and the last 14 days to have earned it (refused not_proven until Fly offers it on a card). With it on, Fly raises bids up to the ceiling, moves budget between campaigns inside the monthly budget, pauses losers, gives winners a fifth more a day and swaps in fresh ads on its own, tells each change after, and steps back by itself if the cost of a sign up doubles. Off any time.{ ads_account_id, on: true | false }
    ads_brand_getAds AgentReadThe brand the ads follow at the place: colours, fonts, when the logo shows, the tone, the lines every ad says and never says, what no picture shows, the languages.{}
    ads_brand_setAds AgentWriteSet the brand the ads follow (owner or admin, signed in), or take it off with null: colours as hex codes (4 at most), fonts (3), logo_use always, never or when_room, tone words (5), must_say lines (5), never_say (10), banned_imagery (10), languages as codes (5). New ads follow it and the running ones are checked against what they must and never say.{ brand: { colours?: string[], fonts?: string[], logo_use?: always | never | when_room, tone?: string[], must_say?: string[], never_say?: string[], banned_imagery?: string[], languages?: string[] } | null }
    ads_campaign_editAds AgentWriteChange one campaign on an ad account Fly runs: its switch, name, daily budgets, a ChatGPT campaign's total (budgets [{ target: campaign, id, lifetime_minor }] on a campaign that runs on a total: daily_minor there answers lifetime_budget, since Fly never turns a total into a daily budget and ChatGPT never turns a daily one back; a raised total on a run whose last day on Fly's record is past or within a day answers a note naming that day, so send a new end_date with it), the last day (end_date YYYY-MM-DD, today or later in the account's zone: Meta's ad sets end on it; ChatGPT keeps no last day of its own, so there it is Fly's own record, nothing is sent to ChatGPT and Fly pauses the run once that day is over, said in notes), its ads' words, page, picture and switch (a Meta ad whose creative Meta keeps whole, such as one with text options, gets a new ad in the same ad set with its words and button and the change, the old ad paused: the result carries replaced { old_ad_id, new_ad_id }; not a new ad on the plan), and on Google Search its Bids (as many clicks with the most a click, or as many results), held to the platform's rules and floor. No other bid: a ChatGPT, Meta, TikTok, X or Reddit bid is the ad set's, set with ads_level_ad_set_change (action bid, cap_minor). A change it does not take answers nothing_changed with where that lives, and nothing is changed.{ ads_account_id, campaign_id, changes: { status?: active | paused, name?, budgets?: [{ target: campaign | adset, id, daily_minor } | { target: campaign, id, lifetime_minor }], end_date?, ads?: [{ id, status?, headline?, body?, button?, link_url?, image_url? }], bidding?: { strategy: max_clicks | max_conversions, cpc_cap_minor? } } }
    ads_campaign_getAds AgentReadOne campaign as its ad account reads it now, led by its budget type (budget_type: daily, lifetime, or not reported), a lifetime budget's total (total_budget_minor, with currency) and its last day (last_day as Mon dd, yyyy in the account's zone and end_date, or last_day not reported where the platform gives none: ChatGPT gives none, its last day is Fly's own record, moved with ads_campaign_edit end_date); then its switch, budget, ad sets and ads with their words, a Google Search campaign's Bids (bidding), and what the owner may change on that platform. A ChatGPT, Meta, TikTok, X or Reddit bid is the ad set's: ads_level_ad_sets_get.{ ads_account_id, campaign_id }
    ads_campaigns_listAds AgentReadEvery campaign of the place's ad accounts (every mode) with its status, switch, budget and the window's spend, impressions, clicks, CTR, CPC, leads and conversions; each account says how fresh its numbers are (numbers_as_of, numbers_state: fresh, stale or none; stale and none are not known, never zero).{ ads_account_id?, from?: YYYY-MM-DD, to?: YYYY-MM-DD }
    ads_campaigns_status_setAds AgentWritePause or run campaigns on one ad account, all or the ids given, and ad sets by id; the owner's own action, so it works on every mode. With no ids a pause takes every campaign switched on; a run always names its campaigns or ad sets. A campaign run brings its ad sets and ads still paused along.{ ads_account_id, status: paused | active, campaign_ids?: string[], adset_ids?: string[] }
    ads_catalogue_getAds AgentReadThe place's catalogue ads: whether it sells from a catalogue (a shop with products, or a vehicle dealer), its product feed (the address the Fly site serves, or a dealer's own inventory feed), each Meta ad account's catalogues and product sets as Fly last read them with the set a catalogue campaign shows, whether Meta's catalogue permission is missing (Fly cannot read catalogues then, and uses the product set ID the owner typed), and the catalogue campaigns Fly made with their product set and format.{}
    ads_change_notices_getAds AgentReadWhether the owner hears of every change to the place's campaigns and ads (Ads Settings, "Tell me about every change to my ads"): the bell at once and an email, at once when the ads stop, else at most one every 15 minutes.{}
    ads_change_notices_setAds AgentWriteSwitch "Tell me about every change to my ads" on or off at the place (owner or admin); off keeps the Activity lines only, no bell and no email.{ on: boolean }
    ads_competitor_addAds AgentWriteName a competitor for the Ads Agent: it reads that company's ads in the Meta Ad Library, Google's Ads Transparency Center and the LinkedIn Ad Library. Read now may read again the same day.{ name, website? }
    ads_competitor_setAds AgentWriteMark a named or suggested competitor as a rival or not a rival, or remove it.{ id, status: rival | not_rival | remove }
    ads_competitors_listAds AgentReadThe competitors named for the Ads Agent at this place (rivals and the suggestions waiting), where each came from, and whether Suggest competitors can run today.{}
    ads_competitors_proposeAds AgentWriteSuggest competitors for the Ads Agent from similar companies and Fly's read, kept as suggestions to answer; once a day per place, spends a data call and an AI call.{}
    ads_conversion_hook_createAds AgentWriteMake the place's hook a server sends its sign ups to (owner or admin, signed in), or make it again after a revoke; the answer carries the secret once, to give the developer. Refused with code exists while one is live.{}
    ads_conversion_hook_getAds AgentReadThe place's hook a server sends its sign ups to (owner or admin, signed in): its address, when it was made and last used, and when it was revoked; never its secret.{}
    ads_conversion_hook_revokeAds AgentWriteRevoke the place's sign ups hook (owner or admin, signed in): its address stops taking sign ups and its secret is cleared.{}
    ads_conversion_hook_rotateAds AgentWriteGive the place's sign ups hook a new secret (owner or admin, signed in); the old secret stops at once and the new one is in the answer once.{}
    ads_conversion_rules_deleteAds AgentWriteDelete one of the place's point and click rules (owner or admin, signed in); its events stay counted.{ rule_id: string }
    ads_conversion_rules_listAds AgentReadThe place's point and click rules: what counts on its own site (reaching a page, a form being sent, a click, an element appearing, the address after a history change), each with its name, the event the networks hear, its health (counting, new, quiet or gone: silent 7 days while the Fly tag sees the site), its real events of the last 30 days, those kept from every network (consent no, GPC), those waiting, and per network Fly runs: sent, and not sent with why (no click id, a network that takes none). Also where the Fly tag was last seen.{}
    ads_conversion_rules_setAds AgentWriteMake a point and click rule, or change one by id (owner or admin, signed in): name Sign up, Purchase, Enquiry or the owner's own word (event sign_up, purchase or lead, else read from the name; an own word stays with Fly); kind page or route with match { o: exact | starts | contains, v: a path such as /thank-you, f?: the path a route comes from }, or kind form, click or element with match { s: a CSS selector, t?: the element's words }; page?: only on that path. Never a selector on what a person types. 20 rules a place. A changed kind, match or page counts as pointed at again.{ rule: { id?: string, name: string, event?: sign_up | purchase | lead, kind: page | form | click | element | route, match: object, page?: string, enabled?: boolean } }
    ads_conversion_sends_listAds AgentReadWhat the Ads Agent sent back to the ad platforms for a range (the last 30 days by default): the sign ups, qualified leads and customers from the customer list by platform, the failures with their reason, the ones taken back on Google, Meta's match quality with what is missing, Google's import actions, and whether sending is on (send_conversions on the strategy).{ from?: YYYY-MM-DD, to?: YYYY-MM-DD }
    ads_conversions_listAds AgentReadThe last sign ups, purchases and leads Fly counted at the place from the site's server or the Fly tag: when, the page, the network, campaign and ad it came from and how Fly knew (fly_ad, utm or the click id), and each network it was sent to, or why not (consent, GPC, a test, no match key).{ limit?: number, from?: YYYY-MM-DD, to?: YYYY-MM-DD }
    ads_creative_lookAds AgentWriteAsk for another look of an ad on a proposed campaign or new creative card. On a campaign ask's card (ads_owner_request) it answers request_card: ask again with the picture wanted as the image.{ action_id, ad?: first | second }
    ads_creative_wordsAds AgentWriteChange the words of an ad on a proposed campaign or new creative card. On a campaign ask's card the words change with ads_request_edit.{ action_id, ad?: first | second, headline, support? }
    ads_google_declaration_madeAds AgentWriteSay the owner made Google's EU political advertising declaration on one Google ad account (owner or admin, signed in): Fly keeps the word, drops Google's refusal it kept, closes its declaration card as done, and the Google changes that failed on it are asked again on the next daily pass (a test's second ad among them); "Where things stand" stops naming the declaration.{ ads_account_id }
    ads_google_suggestion_answerAds AgentWriteOn a card of Google's suggestions for an ad account Fly runs: apply one point on Google Ads (as Fly's take says), or say no so Google stops suggesting it. Never on a Fly recommends account.{ action_id, key, answer: apply | dismiss }
    ads_holdouts_listAds AgentReadThe region tests (geo holdouts) at the place, newest first: the campaign, the place paused for 14 days and the place kept running, asked, running, back or void, the days, and once back the leads each place brought before and during the pause with the reading in words. A test is asked on its own card in every mode, never started here.{}
    ads_hygiene_getAds AgentReadThe Ads Agent's hygiene checks at the place: the open cards for spend running far ahead of the usual day, an ad account on hold and a Display or YouTube campaign to keep off sensitive content; last month's clicks Google filtered as invalid on each Google ad account; whether the site asks each visitor before its ad tags run (consent mode, by the place's country); and each ad account's regulated trade verification, asked or answered.{}
    ads_insights_getAds AgentReadThe Ads Agent's Insights for one part: performance (campaigns, ads, ad sets and day rows), keywords, competitors, decisions or sources.{ part: performance | keywords | competitors | decisions | sources, from?, to?, ads_account_id? }
    ads_instruction_deleteAds AgentWriteDelete an instruction.{ id }
    ads_instruction_readAds AgentWriteHow Fly reads an instruction before it is saved (AI, nothing saved); hand its read.understood to ads_instruction_save.{ instruction }
    ads_instruction_saveAds AgentWriteSave an instruction for the Ads Agent (id to change one).{ instruction, id?, understood?, every_place?: boolean }
    ads_instruction_setAds AgentWritePause or resume an instruction.{ id, active: boolean }
    ads_instructions_getAds AgentReadThe owner's standing instructions for the Ads Agent.{}
    ads_level_ad_group_addAds AgentWriteMake a new ad group for one product in a Google Search campaign on an ad account Fly runs (owner or admin): its name, its keywords (phrase match unless one is marked exact: { text, match: exact } or the search in [square brackets]), the page its ads open (a path on the site the campaign's ads open, or its https address there) and any headlines or descriptions you want; Fly writes the lines you leave out from the campaign's own ads and runs its ad checks, and says what they changed. Refused in words when the campaign is not Google Search, the page does not open, or the plan's ad groups on the account are in use.{ ads_account_id, campaign_id, name, keywords: Array<string | { text, match: phrase | exact }>, page, headlines?: string[], descriptions?: string[] }
    ads_level_ad_groups_getAds AgentReadA Google Search campaign's ad groups, read live from Google: each with its ads, and each ad's headlines and descriptions (with any pin), the pages it opens, and Google's verdict on it (approval, review state and the policy topics Google names). can_change says whether you may change them.{ ads_account_id, campaign_id }
    ads_level_ad_lines_setAds AgentWriteChange a Google Search ad's headlines (10 to 15 of up to 30 letters) and descriptions (4 of up to 90) in place on an ad account Fly runs (owner or admin). Fly's ad checks run first (distinct lines, the ad group's keywords, one keyword insertion) and say what they changed; check_only answers the checked lines without sending. Google reviews the changed ad again.{ ads_account_id, campaign_id, ad_id, headlines: string[], descriptions: string[], check_only?: boolean }
    ads_level_ad_set_changeAds AgentWritePause or run one ad set (the owner's own switch, on every mode), or set its daily budget or its bid, the most it pays (an ad account Fly runs; a bid on Facebook and Instagram, TikTok, ChatGPT, X and Reddit), owner or admin. ChatGPT's bid lives here, on each ad group (its id from ads_level_ad_sets_get), never on the campaign. An Activity line says so.{ ads_account_id, ad_set_id, action: "pause" | "run" | "budget" | "bid", daily_minor? (minor units), cap_minor? (the bid, minor units), campaign_id?, campaign_name? }
    ads_level_ad_sets_getAds AgentReadAn ad account's ad sets (Google, Reddit, TikTok and ChatGPT ad groups, Meta ad sets, X line items, LinkedIn campaigns) on every platform: status, budget, start and end dates, bid, and each one's audiences (interests, communities, keywords, job functions, custom audiences, ages, genders, languages) and places, as the platform last reported them.{ ads_account_id, campaign_id? }
    ads_level_asset_changeAds AgentWriteChange a Google Search campaign's sitelinks, callouts or snippet on an ad account Fly runs (owner or admin): add (links two at a time, each page must open), change or remove one by its asset id from ads_level_assets_get. A changed asset changes everywhere Google uses it.{ ads_account_id, campaign_id, campaign_name?, action: add | change | remove, kind: sitelink | callout | snippet | image (remove only), asset? (change, remove), sitelinks?: [{ text, url, line1, line2 }] (add, two or more), sitelink?: { text, url, line1, line2 } (change), callout?: string, snippet?: { header, values: string[] } }
    ads_level_asset_group_getAds AgentReadA Google Performance Max campaign's asset groups, read live from Google: each group's headlines, long headline, descriptions, business name, wide and square pictures, logo and videos, with its ad strength and whether it serves.{ ads_account_id, campaign_id }
    ads_level_assets_getAds AgentReadEvery asset Google lists for a Google Search campaign, read live: its own, each ad group's and the account's sitelinks (words, two lines, page and whether the page opens now), callouts, structured snippets and pictures; one row each with its type, level, Google's status where Google reports one, who added it (Fly or you) and asset, the id a change names; unread names a part Google did not give. instructions are the place's active Ads instructions.{ ads_account_id, campaign_id }
    ads_level_history_getAds AgentReadAn ad account's change history: the owner's changes, the campaigns the owner made and what Fly did itself on it, newest first, at most 100 lines over a range of up to 92 days (the last 30 by default).{ ads_account_id, from?: YYYY-MM-DD, to?: YYYY-MM-DD }
    ads_level_keyword_changeAds AgentWriteChange a Google Search campaign's keywords on an ad account Fly runs (owner or admin): add up to 20 to one of its ad groups as phrase or exact match (no claims your ads never make), pause, switch back on or remove one by its id from ads_level_keywords_get, or change its match type to phrase or exact (ADS-SEARCH-2: Google adds it again with the new match and the old one is removed).{ ads_account_id, campaign_id, campaign_name?, action: add | pause | run | remove | match, ad_set_id? (add), keywords?: [{ text, match: phrase | exact }] (add), keyword_id? (pause, run, remove, match), match?: phrase | exact (match) }
    ads_level_keywords_getAds AgentReadA Google Search campaign's keywords (or one ad group's) as Google lists them: match type, status, Quality Score and its parts, and the last 30 days' impressions, clicks, cost and conversions. Google lists a new keyword within a day.{ ads_account_id, campaign_id, ad_set_id? }
    ads_level_location_changeAds AgentWriteChange a Google campaign's places on an ad account Fly runs (owner or admin): the full set of places it shows in (never none), the places it leaves out, or who they reach (presence: people in them; presence_or_interest: also people searching for them). Each list replaces that list.{ ads_account_id, campaign_id, locations?: [{ type, code, id }], excluded_locations?: [{ type, code, id }], reach?: "presence" | "presence_or_interest", campaign_name? }
    ads_level_negatives_changeAds AgentWriteKeep searches out of a Google Search campaign, or let them back in, at the campaign level on an ad account Fly runs (owner or admin): add or remove negative keywords as exact, phrase or broad match. Fly reads Google's list first and keeps every negative already there; only the ones named change. Keeping a search out spends nothing.{ ads_account_id, campaign_id, campaign_name?, action: add | remove, keywords: [{ text, match: exact | phrase | broad }] (remove: match? takes out every match of the words when left out) }
    ads_level_negatives_getAds AgentReadA Google Search campaign's negative keywords at the campaign level, read live from Google: each search the campaign never shows on, with its match type (exact, phrase or broad), whoever set it, Fly or you in Google Ads. can_change says whether you may change them.{ ads_account_id, campaign_id }
    ads_level_schedule_getAds AgentReadThe days and hours ads show: a Google campaign's windows (with include_performance, its impressions, clicks, cost and conversions by day of week and by hour over the last 30 days, in the account's time zone), or a Meta account's ad sets' whole hours. Other platforms take only start and end dates and answer unsupported.{ ads_account_id, campaign_id? (Google), ad_set_id? (Meta), include_performance?: boolean }
    ads_level_schedule_setAds AgentWriteSet the days and hours ads show on an ad account Fly runs (owner or admin): a Google campaign's windows in quarter hours, at most 6 a day, or clear: true for any hour of any day; a Meta ad set's whole hours (Meta runs them on a lifetime budget only; an empty list takes them off). Other platforms take none. A REPLACE: windows left out stop showing.{ ads_account_id, campaign_id? (Google), ad_set_id? (Meta), schedule?: [{ dayOfWeek: "MONDAY".."SUNDAY", startHour, startMinute?, endHour, endMinute? }], clear?: boolean, campaign_name? }
    ads_level_targeting_getAds AgentReadA Google campaign's places (with their names and kinds), the places it leaves out, its languages and devices, and whether it reaches people in the places or also people searching for them.{ ads_account_id, campaign_id }
    ads_list_deleteAds AgentWriteDelete one of the owner's lists (owner or admin, signed in): nothing of it on Meta yet, it goes at once; else Fly deletes the audience on Meta on its next pass and then the list. An open ask aimed at it goes back to everyone the ad aims at.{ list_id: string }
    ads_list_remove_peopleAds AgentWriteTake people off one of the owner's lists (owner or admin, signed in): off Fly's list at once, off Meta on the next pass. rows are the people by email or phone, 5,000 at most.{ list_id: string, rows: [{ email?: string, phone?: string }] }
    ads_list_retryAds AgentWriteTry a list again on Meta after its ad account's admin accepted Meta's Custom Audience terms (owner or admin, signed in): the refusal is cleared and the next pass tries again now.{ list_id: string }
    ads_lists_readAds AgentReadThe owner's own lists at the place (people who gave the business their details, uploaded in the app): each list's name, where its people came from, status (draft under Meta's least of about 100 people, ready, refused, deleting) and why, the rows uploaded, the people kept and the rows left out by reason, and its audience on each Facebook and Instagram ad account (status, people Meta matched, refused with the next step). Counts only, never a person.{}
    ads_money_getAds AgentReadThe month's money at the place, in the budget's currency (at the day's rate where an ad account spends in another): the monthly budget against what was spent, where the month ends at this pace and what is planned; a row an ad account with its cap and the room left, Fly's spend forecast for it, what was paid (to the platform, with its billing page, or from the Fly wallet), the ad leads and customers of the month with the cost of each and the payback where the value of a customer is set, and whether its numbers are in. This month by default, else one of the last 6. WO-E: fly_work is Fly's own cost of running the Ads Agent here this month (its AI, Treg and the supplier calls it keeps, never the ad spend) against $10 an ad account Fly runs: allowance_usd, spent_usd, room_usd, state (fine, tight from 70%, over, unknown where a cost source could not be read) and as_of; null for a past month or before Fly read it. Tight holds Fly's optional AI and checks running ads one step less often; over checks once a day and makes nothing new unless the owner asks on a card.{ month?: YYYY-MM }
    ads_proposal_approveAds AgentWriteApprove a campaign proposal: the owner or an admin, or the business's client while the agency lets them (Your client's approvals on the strategy). Fly sets the campaign up paused; switching it on stays the agency's, so a client's yes never spends.{ action_id: string }
    ads_recommendation_item_setAds AgentWriteAnswer one point of an Ads review card: done, or not now (later).{ action_id, key, state: done | later }
    ads_recommendations_listAds AgentReadThe Ads review cards of the ad accounts Fly reads and advises (Fly recommends): each point with why, steps and where.{ ads_account_id?, open_only?: boolean }
    ads_request_audience_setAds AgentWriteSet who sees an open ask card's Facebook and Instagram ads (owner or admin, signed in): only the people on one of the place's ready lists (ads_lists_read), or null for everyone the ad aims at. A list not on the card's ad account yet keeps that ad waiting until it is. Before Create campaigns only.{ action_id: string, list_id: string | null }
    ads_request_createAds AgentWriteAsk the Ads Agent for campaigns about one thing on the ad accounts picked: it writes the words and pictures and answers with one card to check; nothing is made or spent until the owner says so on the card.{ request: { request_id?, subject: { kind: service | product | offer | new, ref, name, words, price }, campaign: { goal: traffic | calls | awareness | signups | leads (signups and leads map to each platform's own objective: Meta and ChatGPT conversions, Meta's enquiry form, Google visits bid by its tracking; the New campaign flow starts on the strategy's goal), name, end_date, area: { kind: pin | country, radius_km? }, segment? (who the ads are for, 2 to 40 letters, like Salons; the Ads review board filters by it), platforms: [{ ads_account_id, objective, daily_minor | lifetime_minor, extras?, format?, ad? }], ad: { link_url, headline?, body?, button?, image_url?, google?: { headlines, descriptions, keywords } } } }. WO-A A3: the shared ad, or a platform's own ad, may carry the owner's headline (up to 40 letters), body, button (Learn more | Book now | Contact us | Order now | Shop now | Sign up | Get offer | Get directions), an https image_url and Google's headlines, descriptions and keywords; Fly writes and draws what is left out
    ads_request_create_stepAds AgentWriteAnswer an ask's card: create makes the campaigns paused, live switches them on (production only; the test environment keeps them paused), leave keeps them paused and closes the card.{ action_id, step: create | live | leave }
    ads_request_editAds AgentWriteChange an ask's card before anything is made: the words, page, button and budget per platform, the last day, and who the ads are for (segment; null clears it).{ action_id, platforms?: [{ ads_account_id, headline?, body?, button?, link_url?, daily_minor?, lifetime_minor?, google? }], end_date?, segment? }
    ads_request_optionsAds AgentReadWhat a campaign ask to the Ads Agent may be about (services, products, running offers), each ad account Fly runs with its objectives, what each needs, its least daily budget and what holds it back.{}
    ads_requests_listAds AgentReadThe place's campaign asks to the Ads Agent with their state (waiting, making, made, failed), their card, its previews per platform and the campaigns made.{ open_only?: boolean }
    ads_review_angle_newAds AgentWriteNew copies with an angle on an ask card: angle names the angle to attack (Fly scores it beside its own, keeps it with the card's angles and drafts it as a new ad beside the others in the same Meta ad set, saying where it ranks; a network that takes one ad an ask has its ad drawn from it, the old kept as a version), or angle_id drafts one of the card's angles not drafted yet (Draft this angle too). Each new ad counts as a new ad on the plan. Signed in, the owner or an admin.{ action_id: string, angle: string, ads_account_id?: string } | { action_id: string, angle_id: string, ads_account_id?: string }
    ads_review_angles_getAds AgentReadThe angles of an ask card (ads_owner_request): each with its angle line, takeaway, why it should convert, the proof it needs, its score 0 to 100 with the reason and the evidence of Fly's own numbers where they exist, highest first; each ad on the card with its angle (first, second and on, the ads in the same ad set); the angles not drafted; the refines asked with their answers; the campaign refine with its proposed edits.{ action_id: string }
    ads_review_feedbackAds AgentWriteLeave feedback on one ad of an ask card: a comment on the card's thread (card:<action_id>), which the team and the agency see. Signed in.{ action_id: string, body: string, which?: first | second | v3 | v4, ads_account_id?: string }
    ads_review_listAds AgentReadThe Ads review board: the Ads Agent's answers to the owner's asks of the last 120 days, newest first, each with its state (To review, Made, paused, Live, Closed, Failed), segment, the ask's name, its time and its app address, and each network's ad (words, picture, page, budget, last day, campaign) with who the ask said it is shown to (area, countries, cities, radius, ages, gender, interests, languages; null where the ask recorded none); facets counts the ads by region, segment, age, gender, network and state.{}
    ads_review_refine_adAds AgentWriteRefine one ad of an ask card with the owner's words (3 to 600 letters): before anything is made, Fly draws its words and picture again on a pass that starts now, keeps its angle unless the words change it, keeps the old as a version and answers on the card (refine_asks) and the thread; once made, the change goes to the running ad as a new version on its own card. Four asks wait on a card at most. Signed in, the owner or an admin.{ action_id: string, words: string, which?: first | second | v3 | v4, ads_account_id?: string }
    ads_review_refine_campaignAds AgentWriteRefine an ask card's campaign: with words (who, where, how much or until when) Fly answers on the card with the concrete edits for a yes (campaign_refine: lines, spends_more), never applied unasked; answer yes applies them (before anything is made to the ask and its previews, each network held to the create's checks; after, the last day and the budgets through ads_campaign_edit), no leaves it as it is. Signed in, the owner or an admin.{ action_id: string, words: string } | { action_id: string, answer: yes | no }
    ads_rules_listAds AgentReadThe owner's own rules for the Ads Agent at the place (at most 10), each in words, with what a rule may watch and do and the place's money for a new one. The agent applies them first on every daily pass, before its own checks.{}
    ads_rules_setAds AgentWriteAdd, take off or replace the owner's rules for the Ads Agent (owner or admin, signed in): words reads one rule said plainly ("pause a campaign when a result costs over Rs 500 in 7 days", "tell me when a campaign spends over 2,000 a day", "lower the daily budget to Rs 1,000 when under 0.5% click"), or add takes it as fields. A rule watches a result's cost, a day's spend, the click rate or spend with no result over 1 to 30 days, and pauses the campaign, tells the owner or lowers its daily budget.{ words?: string } | { add?: { when: cost_per_result_over | daily_spend_over | ctr_under | no_results_after_spend, value_minor? (money, minor units), value? (ctr_under: percent), currency?, window_days?: 1..30, then: pause | tell | lower_daily_to, to_minor? } } | { remove?: rule id } | { rules?: rule[] }
    ads_setup_session_createAds AgentWriteSet up what counts: a one-time link (15 minutes, single use, this business only) that opens the owner's own site with Fly's set-up toolbar, to point at the thank-you page, a form, a button or a message (owner or admin, signed in). page: the https page to open on one of the business's domains (its website by default); rule_id: a rule to point at again. Give the owner open_url to open themselves; it works once the Fly tag is on that site (tag_seen).{ page?: string, rule_id?: string }
    ads_site_conversion_testAds AgentWriteSend a signed test sign up through the place's real hook (owner or admin, signed in) and answer what Fly recorded; a test proves the route, is never counted as a result and never sent to a network.{}
    ads_site_domains_setAds AgentWriteSet the owner's own domains the Fly tag counts on, beside the place's website (owner or admin, signed in; ten at most).{ domains: string[] }
    ads_site_key_getAds AgentReadThe Fly tag's public site key for the place (made on the first ask by the owner or an admin), the domains it counts on, the page and time the tag was last seen, and the route that lets Fly judge the ads on sign ups (verified, by hook, tag or Fly site, since when).{}
    ads_site_key_rotateAds AgentWriteGive the Fly tag a new site key (owner or admin, signed in); the pasted tag must then carry the new key.{}
    ads_strategy_getAds AgentReadThe Ads strategy: the monthly budget, each platform's cap and whether it is off, the lead service, the goal, the offer, the area, how often Fly checks on running ads (pace_minutes 30, 60, 180 or 360, null once a day, with pace_words) (WO-E: pace_words also says the pace this month where Fly's own work allowance steps it down, "every hour (every 3 hours this month, within Fly's work allowance)", while pace_minutes stays the owner's setting), whether campaigns go live on this test environment (live_here), and whether the customer list's sign ups and customers go back to the ad platforms (send_conversions on, off or null when never set) with the value of one customer (customer_value_minor, customer_value_currency); WO-F3: each ad account Fly runs with its Autopilot (autopilot: on, since, line "Autopilot on since Nov 08, 2026" or "Fly can run this on its own: see the card"; ads_autopilot_set switches it). ADS-AIM-1: beside the settings, the aim the Ads Agent works to (aim: cost_divisor and results_multiple, 3 and 3 unless the place has its own; cost_minor, a result at a third of what one cost before Fly, and results_month, three times as many a month, both null until the mark is known; currency; standing there, not_yet or unset for the month so far, null where the place has no aim; words, the line to say), read only.{}
    ads_strategy_setAds AgentWriteChange the Ads strategy (owner or admin): monthly budget, platform caps, a platform off, lead service, goal, offer, area, how often Fly checks on running ads (pace_minutes; between the daily passes a light pass reads the running ads, tells what changed and finishes what waits on a platform); live_here lets campaigns go live on a test environment, Fly staff only, refused in production; send_conversions sends the customer list's sign ups, qualified leads and customers back to the ad platforms Fly runs (false stops it); customer_value_minor is the value of one customer, sent with each customer (null takes it off); inventory_feed_url is a vehicle dealer's own inventory feed address, passed on in the catalogue cards, and catalog_set_id the Meta product set the catalogue campaign shows while Fly cannot read the catalogues (ADS-SHOP-1; null takes either off); deploy runs the Ads Agent's pass now. Answers each change in words.{ edits: { monthly_minor?, caps?: { platform: minor | null }, off?: { platform: boolean }, focus?, goal?, offer?, radius_km?, areas?: string[], pace_minutes?: 30 | 60 | 180 | 360 | null, live_here?: boolean, send_conversions?: boolean, customer_value_minor?: number | null, inventory_feed_url?: string | null, catalog_set_id?: string | null }, deploy?: boolean }
    ads_tests_listAds AgentReadThe Ads Agent's tests at the place: each Facebook and Instagram ad set whose two ads are judged against each other (running, decided or void), with each ad's views, clicks, spend and results since the test began, the days left to a decision (21 at most), the ad kept and the lift for a decided one, whether the owner's yes is still asked, and how a void one ended.{ status?: running | decided | void }
    ads_tracking_overrideAds AgentWriteHow one ad account Fly runs is judged while its sign ups cannot be counted: run false holds its ads until they count (the owner's opt in: Fly pauses its running campaigns there on the next daily pass); run true takes the hold back, the default, so the ads run judged on clicks and visits and Fly switches back on what it paused. Owner or admin, signed in.{ ads_account_id, run: boolean }
    ads_voice_getAds AgentReadHow the place's ads sound: one tone for all networks and, for each network with an ad account connected, its own tone or the same as all, and its native touches (each with its line and the network's published page it rests on) and whether each is on. A tone has three axes, each one of three: register conversational, neutral or formal; humour playful, neutral or straightforward; attitude cheeky, neutral or respectful. Neutral with no touch changes nothing. The touches are not proven to lift results; where Fly tests two ads, one carries the voice and one stays neutral.{}
    ads_voice_setAds AgentWriteSet how the place's ads sound (owner or admin, signed in), for all networks or one ("make my Reddit ads more conversational": network redditads, tone register conversational). tone sets any of register, humour and attitude; touches replaces a network's touches by key (ads_voice_get lists them); same_as_all puts a network back on the all networks tone; reset takes a network back to the all networks tone with no touches, or all networks back to neutral (each network's own tone stays). The owner's instructions for ads always come first. The next ads Fly writes on that network sound this way.{ network: all | metaads | googleads | openaiads | linkedinads | xads | pinterestads | redditads | tiktokads, tone?: { register?: conversational | neutral | formal, humour?: playful | neutral | straightforward, attitude?: cheeky | neutral | respectful }, touches?: string[], same_as_all?: boolean, reset?: boolean }
    ads_weekly_send_nowAds AgentWriteSend this week's ads email now: the week so far (Monday to yesterday, or the last 7 days on a Monday) goes to the owner on the next Ads pass, whatever the day or the hour, with the links to the Ads report and to everything the agent did. Signed in; the Ads Agent must be on at the place.{}
    ga_ads_connectAds AgentWriteConnect Google Analytics for the business (owner or admin, signed in): answers Google's consent address to open; the Website Agent uses the same connection. Answers already when the business has one.{ ads_account_id }
    ga_ads_recheckAds AgentWriteCheck a Google Ads account's Google Analytics again now, after the owner did a step: its key events and Google Ads links read through the business's one connection, the kept read and the open card brought up to date in place, what changed in one line. At most once every 5 minutes an account.{ ads_account_id }
    ga_ads_setupAds AgentWriteLet Fly set up sign up tracking (owner or admin, signed in): where Google Analytics offers edit access, Fly marks the sign up event as a key event and links the Google Ads account, after one consent to widen the connection. Answers edit_not_offered with the steps while Google Analytics connects read only.{ ads_account_id, event?, property? }
    ga_ads_stateAds AgentReadA Google Ads account's Google Analytics: the business's one connection (shared with the Website Agent), whether Fly may set up sign up tracking itself, and the four steps (key event, link, import, auto-tagging) as the last pass saw them, with Google's help page for each. Recommended, never required.{ ads_account_id }
    askAccountReadAsk the agent a question about this location (read only, never acts).{ question }
    ask_conversationAccountWriteOne conversation (a pending refresh in it is claimed, so it needs fly:write).{ conversation_id }
    ask_conversationsAccountReadThe Ask conversations.{}
    ask_refreshAccountWriteRefresh a stale answer (may queue a pass).{ conversation_id, event_id }
    ask_refresh_answerAccountWriteThe refreshed answer (written to the conversation, so it needs fly:write).{ conversation_id, event_id }
    ask_sendAccountWriteA line to the agent from the Ask panel: answered from what it knows, or made into work.{ instruction, conversation_id?, new_conversation? }
    ask_suggestionsAccountReadSuggested asks.{}
    ai_autotopup_getAccountReadAuto top-up of the Fly AI credits: on or off, the threshold, the block, whether a card or UPI is saved.{}
    ai_autotopup_setAccountWriteSwitch auto top-up of a balance on or off, with its threshold and block in minor units (on needs a card or UPI saved on the Billing page).{ kind?: fly_ai_balance | content_balance, on: boolean, threshold_minor?, block_minor? }
    ai_balancesAccountReadEvery balance of the workspace: the Fly AI credits, the Content agent balance where it is open, and each auto top-up.{}
    ai_credits_getAccountReadThe Fly AI credits of the workspace: the balance, this month's free allowance, the least a turn needs, auto top-up.{}
    ai_ledgerAccountReadThe Fly AI credits ledger, newest first, 50 rows a page at most.{ limit?: 1..50, before?: ISO }
    ai_modelsAccountReadThe models Fly AI offers, each with its price per million tokens in and out and the cost of a typical ask in dollars, and the rupees a dollar is charged at.{}
    ai_settings_getAccountReadFly AI's settings for the person: the default location and agent, whether it asks before it changes anything, the model, the effort, the tool calls a reply and the spend cap a reply, with the models it offers.{}
    ai_settings_setAccountWriteChange those settings (null or an empty string clears a default; max_tool_calls cleared is 50 again; turn_spend_cap_minor 0 is no cap).{ default_location_id?: uuid | null, default_agent?: local | social | ads | web | citations | manager | null, confirm_writes?: boolean, model?: auto | anthropic/claude-sonnet-5.5 | anthropic/claude-haiku-5.5 | anthropic/claude-opus-5.5 | null, effort?: low | medium | high | null, max_tool_calls?: 1..100, turn_spend_cap_minor?: 100..100000 | 0 | null }
    ai_topup_linkAccountReadThe Billing page address where the owner buys a block of a balance; nothing is bought here.{ kind?: fly_ai_balance | content_balance }
    ai_whatsapp_addAccountWriteAdd a WhatsApp number: a 6 digit code goes to it (the account's verified phone needs none). Only on a connection given every workspace, location and agent.{ phone: E.164, workspace_ids?: uuid[] }
    ai_whatsapp_listAccountReadThe WhatsApp numbers that reach Fly AI for the person, the account phone among them.{}
    ai_whatsapp_removeAccountWriteRemove a WhatsApp number.{ id }
    ai_whatsapp_verifyAccountWriteVerify a number with the code it got.{ id, code }
    booking_addLocal AgentWriteAdd a booking by hand.{ name, phone?, email?, date, time, service?, note?, notify? }
    booking_link_changeLocal AgentWriteUse your own booking link, or Fly's.{ action_id, url } | { action_id, fly: true }
    bookingsLocal AgentReadThe month's bookings.{ month: YYYY-MM }
    before_start_answerAccountWriteAnswer a step, or start.{ agent, step, answers?, skipped? } | { start: true, agents? }
    before_start_proposeAccountWriteA step's proposal (AI); step is one of the agent's steps from before_start_state.{ agent: local | web | social | ads | citations, step, q? }
    before_start_stateAccountWriteWhat the agents ask before they start, with each agent's steps (skip and seed change the steps, so it needs fly:write).{ agents?: [local | web | social | ads | citations], skip?: [products | categories], seed?: true }
    broadcast_approveAccountWriteApprove a broadcast.{ broadcast_id }
    broadcast_cancelAccountWriteCancel a broadcast.{ broadcast_id }
    broadcast_createAccountWriteMake a broadcast.{ kind: social_post | google_post | offer | article, title?, content: { text, image_url?, link?, offer?: { what, start, end, terms?, code? } }, targets?: all | selected, target_location_ids?, variation?: local_details | per_location_rewrite, approval?: brand | per_location, schedule_at?, source_post_id? }
    broadcast_getAccountReadOne broadcast.{ broadcast_id }
    broadcast_item_retryAccountWriteRetry one location of a broadcast.{ item_id }
    broadcast_listAccountReadThe business's broadcasts to its locations.{}
    business_knowledge_add_noteAccountWriteAdd a note to the knowledge (text 10 to 5000 characters; a usp is one line).{ about: services | catalogue | usp | process | terms | faq | other, title?, text }
    business_knowledge_add_offerAccountWriteAdd an offer to the knowledge.{ title, details, terms?, valid_from?, valid_until }
    business_knowledge_listAccountReadBusiness knowledge every agent reads: documents, notes, offers.{}
    business_knowledge_removeAccountWriteRemove a knowledge item.{ context_id }
    business_profileAccountWriteYour business: kind, audience, products (read with no changes).{ changes?: { kind?: local | online | hybrid, audience?, products?: string[] } }
    business_reply_rules_getAccountReadThe reply rules for a channel.{ scope: inbox | reviews }
    business_reply_rules_saveAccountWriteSave the reply rules for a channel (one rule a line; replaces them, empty clears).{ scope: inbox | reviews, text }
    content_library_getAccountReadOne library asset.{ asset_id }
    content_library_keepAccountWriteKeep a creative in the library.{ ref }
    content_library_listAccountReadThe content library: every creative of the business.{ kind?: image | video | reel | banner | flyer | gif, agent?: local | social | ads | web, network?, place?, from?: YYYY-MM-DD, to?: YYYY-MM-DD, source?: posted | uploaded | fly | you | creator_hub, before?, limit? }
    content_library_removeAccountWriteRemove a library asset.{ id } | { ref }
    content_source_deleteAccountWriteDelete a content source.{ id }
    content_source_saveAccountWriteAdd or change a content source.{ id?, name, url, format: json | feed, headers?: [{ name, value? }], items_path?, field_map?, per_week?, enabled?: boolean, scope?: location | workspace }
    content_source_testAccountWriteTest a content source.{ id?, url?, format?: json | feed, headers?, items_path?, field_map? }
    content_sources_listAccountReadThe owner's content sources (feeds).{}
    packs_getAccountReadThe one-time packs and their orders.{ order_id? }
    plan_move_decideAccountWrite"Not now" on a plan card.{ action_id, decision: declined }
    citations_ask_answerListings AgentWriteAnswer a question the agent stopped on: a code, a yes, a password.{ source_id, ask_id, value }
    citations_detailListings AgentReadThe directory listings and their state.{}
    citations_picturesListings AgentReadThe last pictures the agent took at a place.{ source_id, limit?: 1..12 }
    citations_place_againListings AgentWriteStart a directory the agent has not started on, or try one again (the owner must be around for the code the site sends).{ source_id }
    citations_plan_fillListings AgentWriteTake on the directories a card offered.{}
    citations_plan_getListings AgentReadThe Listings Agent's plan: the directories chosen and their state.{ part?: overview }
    citations_plan_researchListings AgentWriteResearch the directories worth listing on.{}
    citations_plan_selectListings AgentWriteChoose the directories.{ selected: string[] }
    citations_request_declineListings AgentWrite"I do not have this".{ source_id, key }
    citations_shelf_getListings AgentReadThe documents and answers the owner gave the Listings Agent.{}
    citations_shelf_putListings AgentWriteGive a number or an answer (files go through the app).{ type, kind: number | answer, value, question? }
    citations_shelf_removeListings AgentWriteRemove one from the shelf.{ type }
    citations_source_addListings AgentWriteAdd a directory by URL.{ url, name? }
    citations_source_removeListings AgentWriteRemove a directory you added by URL, while the agent has not started on it (its id from citations_plan_get).{ source_id }
    action_statusAccountReadHow the cards this caller raised ended.{}
    attachAccountWriteSend the agent a picture or a file with an instruction.{ media_kind, instruction, url? }
    card_recheckAccountWriteCheck a finished card against Google again.{ action_id }
    card_recheck_statusAccountReadHow a recheck is going.{ action_id }
    changed_atAccountReadWhen the cards, drafts and reviews last changed.{}
    early_accessAccountReadWhich beta agents and staff views this account may see.{}
    event_detailAccountReadOne activity line in full.{ event_id }
    eventsAccountReadThe activity trail, a page at a time.{ offset?, limit? }
    fyi_seenAccountWriteGot it on an FYI card.{ action_id }
    getAccountReadThe agent home: the location, the cards, the activity, rank, health, the plan.{}
    get_dashboard_dataAccountReadThe dashboard numbers for the location.{}
    growth_stateAccountReadThe growth loop: what moved and what is lined up.{}
    healthAccountReadThe health signals and the worker heartbeat only.{}
    instructionsAccountWriteTell the agent something (a standing rule, a one-off job, a question), retire a standing rule by its id, or list the standing rules with their ids (no params).{} (lists the standing rules) | { instruction } | { deactivate_id }
    notification_readAccountWriteMark one notification read.{ id } | { all: true }
    notification_read_allAccountWriteMark every notification read.{}
    notificationsAccountReadThe notifications list.{ filter?, offset?, limit? }
    paused_lineAccountReadThe line held work shows while the agent is paused.{}
    respondAccountWriteApprove, decline, mark done, dismiss, submit or undo a card.{ action_id, decision: approve | reject | done | dismiss | submit | change | undo_dismiss, reply_text?, inputs? }
    runsAccountReadThe agent passes, newest first.{ limit?, before? }
    setup_dismissAccountWriteDismiss the set-up strip.{}
    tickAccountWriteQueue a pass now, all stages or the named ones (the early access gate may refuse).{ checks?: string[] }
    work_summaryAccountReadCounts of what the agent did, all time and the last 30 days.{ all?: boolean }
    add_keywordLocal AgentWriteTrack a search term on the map grid.{ keyword }
    edit_keywordLocal AgentWriteChange a tracked search term.{ keyword_id, keyword }
    get_keyword_recommendations_contextLocal AgentReadWhat the agent knows for suggesting search terms.{}
    get_keywords_dataLocal AgentReadThe tracked search terms with their map grid ranks and history.{}
    remove_keywordLocal AgentWriteStop tracking a search term.{ keyword_id }
    ads_review_linkAccountWriteThe Ads review board's share link (opens without signing in, read only, nothing can be approved or changed on it): the place's link, reused while it has more than a day left, else a new one for 90 days.{}
    connect_linkAccountWriteA fresh Google connect link for adding a location to this workspace.{}
    connect_share_linksAccountWriteThe social, ads and web connect links to share with whoever manages the accounts.{ kinds?: [social | ads | web], audience?: owner | manager, sent?: boolean }
    page_linkAccountWriteA share link (a token page that opens without signing in) of one type.{ link_type: home | review_generator | review_responder | references | templates | social_connect }
    page_linksAccountReadThe address of every page of the location for the signed-in owner.{}
    report_shareAccountWriteAn agent report's share links: list, make (private or showcase), switch off.{ agent: local | social | ads | web, action: list | make | off, kind?: private | showcase, show_name?, show_money?, link_token? }
    button_contextLocal AgentReadThe links a post button may point at.{}
    calendarLocal AgentReadThe content calendar: published, scheduled, approved and draft posts by day (62 days at most).{ from: YYYY-MM-DD, to: YYYY-MM-DD }
    create_postLocal AgentWriteMake a Google post now or at a time; to the connected social networks too (social_targets are the social_account_id values from social_targets).{ summary, type?: STANDARD | EVENT | OFFER, media_urls?: string[], call_to_action?, event_info?, offer_info?, scheduled_at?: ISO, content_idea_id?, social_targets?: social_account_id[], to_google?: boolean }
    done_cardsLocal AgentReadEvery finished card, page by page (send next_before back as before for the next page).{ before?: ISO, limit?: 1..60 }
    done_postsLocal AgentReadThe drafts the owner has answered.{}
    draft_buttonLocal AgentWriteThe button on one draft (every button but NONE and CALL needs its url).{ idea_id, type: NONE | LEARN_MORE | BOOK | ORDER | SHOP | SIGN_UP | CALL, url? }
    draft_dateLocal AgentWritePick the day (or the day and time) a waiting draft goes out; a day that has a post already asks confirm_shared.{ idea_id, day: YYYY-MM-DD, confirm_shared?: boolean } | { idea_id, at: ISO, confirm_shared?: boolean }
    draft_frameLocal AgentWriteChoose the frame for one draft.{ idea_id, frame_id }
    draftsLocal AgentReadThe post drafts waiting for review, as cards.{}
    festivals_getLocal AgentReadThe festivals month posts are made for: the well-known list for the business's country, or the workspace's own list.{}
    festivals_setLocal AgentWriteKeep the workspace's own festival list for the business's country, or go back to the well-known list. Signed-in callers only.{ use_own, festivals: [name] }
    frame_in_useLocal AgentReadThe frame in use.{}
    frame_previewLocal AgentWriteDraw a picture (in Fly storage) inside a frame, a preview; with no frame named, the frame in use.{ image_url, model_frame_id? | template_id?, fit?: whole }
    frame_setLocal AgentWriteSet the frame every post uses (null for none).{ template_id | null }
    framesLocal AgentReadThe frames the business may post in.{}
    held_postsLocal AgentReadThe approved posts the agent is holding, with why.{}
    idea_decisionLocal AgentWriteApprove or reject a draft; approve with publish to post it now or at a time (two hours ahead at least), else the agent picks the time.{ idea_id, decision: approve | reject, publish?: { mode: now | at, at?: ISO } }
    idea_feedbackLocal AgentWriteAsk for a change on a draft: the words, the picture or both.{ idea_id, feedback, target: words | picture | both }
    idea_for_editorLocal AgentReadA draft's words and picture for editing.{ idea_id }
    idea_rescheduleLocal AgentWriteMove a scheduled or approved draft to a new time (two hours ahead at least).{ idea_id, scheduled_at: ISO }
    idea_reviseLocal AgentWriteChange the words of a draft with an instruction.{ idea_id, instruction }
    idea_withdrawLocal AgentWriteTake a draft back: cancel its schedule or delete it.{ idea_id, mode: cancel | delete }
    model_frame_chooseLocal AgentWriteChoose one designed frame.{ frame_id }
    model_frame_refineLocal AgentWriteRefine a designed frame with an instruction.{ frame_id, instruction }
    model_framesLocal AgentReadThe frames the image model designed for the business.{}
    model_frames_generateLocal AgentWriteDesign new frames for the business (AI, counts on the plan).{ source?: settings | onboarding }
    offer_changeLocal AgentWriteChange the offer post's words or picture.{ action_id, target: words | picture | both, instruction, title?, summary? }
    offer_change_statusLocal AgentReadHow an offer change is going.{ action_id }
    offer_createLocal AgentWriteThe owner's own offer for a month.{ month, offer_what, offer_terms?, offer_start, offer_end, offer_code?, offer_link? }
    offer_getLocal AgentReadThe month's offer post.{ month?: YYYY-MM }
    offer_scheduleLocal AgentWriteSchedule the offer post.{ action_id, title, summary, start, end, code?, link?, terms?, image_url?, no_image? }
    offer_submitLocal AgentWriteSubmit the offer card's inputs.{ action_id, inputs: { offer_running: yes | no | suggest, offer_what?, offer_start?: YYYY-MM-DD, offer_end?: YYYY-MM-DD, offer_terms?, offer_code?, offer_link? } }
    offer_title_suggestLocal AgentWriteA title for an offer (AI).{ text?, caption?, topic? }
    plan_usageLocal AgentReadThe posts and frames the plan has left this month.{}
    post_cancelLocal AgentWriteCancel a post you made (fly_post_create or the New post page) that has not gone out: its Google post and its social posts.{ post_id }
    post_draft_deleteLocal AgentWriteDelete a saved New post draft.{ draft_id }
    post_draft_getLocal AgentReadOne saved New post draft.{ draft_id }
    post_draft_saveLocal AgentWriteSave a New post draft.{ draft_id, state, step?, networks? }
    post_draftsLocal AgentReadThe New post page's own saved drafts.{}
    post_rescheduleLocal AgentWriteMove a post you made that has not gone out to a new time, ten minutes ahead at least: its Google post and its social posts.{ post_id, scheduled_at: ISO }
    posts_generateLocal AgentWriteWhat is being written now ({}), ask for a week, a month or a range of posts, or ask for one post per typed topic on its date (check them with topics_check first).{} | { from, to, kind: week | month | custom, count? } | { topics: [{ date, topic, repeat_ok?, off_service_ok? }] }
    topics_checkLocal AgentReadCheck typed post topics before asking for them: which repeat a post from the last 90 days, which name none of the listed services, and the days that already hold a draft.{ from, to, topics: [{ topic, date? }] }
    write_postLocal AgentWriteWords for a post from a brief or a rough draft (AI).{ text, post_type?: STANDARD | OFFER | EVENT, rewrite?: shorter | warmer | formal | cta }
    agent_changesLocal AgentReadEvery change the agent made on the profile, grouped.{}
    branding_designLocal AgentWriteThree cover designs on the cover photo card (AI).{ action_id }
    category_searchLocal AgentReadSearch Google's category list.{ q }
    category_suggestLocal AgentWriteCategories the agent suggests (AI).{}
    delete_photoLocal AgentWriteRemove a photo from the library.{ photo_id }
    description_suggestLocal AgentWriteA description for the profile (AI).{}
    description_variantsLocal AgentWriteThree description angles (AI).{}
    get_gbp_attributesLocal AgentReadThe attributes on the Google profile.{}
    get_gbp_servicesLocal AgentReadThe services on the Google profile.{}
    get_optimize_dataLocal AgentReadThe profile audit: scores and what to fix.{}
    get_photosLocal AgentReadThe photo library and what went to Google.{}
    guard_getLocal AgentReadProfile Guard for the location: on or off, each protected field with its master value, the value on Google now and its mode, the owners and managers on Google (the expected ones marked), the verification reason with what to do, and the last 50 events.{ refresh?: boolean }
    guard_rollbackLocal AgentWritePut one protected field back to its master value on Google now (a person's roll back of a change Profile Guard held).{ field: phone | website | name | description | regular_hours }
    guard_setLocal AgentWriteSwitch Profile Guard on or off, set a field's master value (Keep the change sets the new value) or its mode (rollback puts it back automatically where safe, watch only reports), the expected owners and managers, or the weekly roll back cap. Switched on the first time, the master values are taken from Google.{ enabled?: boolean, fields?: { phone | website | name | description | regular_hours: { golden?, mode?: rollback | watch } }, expected_admins?: [{ admin_key, admin?, role }], rollback_cap_per_week?: 0 to 10 }
    photo_scheduleLocal AgentWriteList the scheduled photos, or schedule photos to Google.{ mode: list } | { photos: [{ url, category }], mode: schedule | agent | cadence, at?, every_days? }
    photos_to_libraryLocal AgentWriteAdd photos by URL to the library.{ photos: [{ url, category, scheduled_for? }] }
    photos_to_profileLocal AgentWriteSend reference photos to the Google profile.{ reference_ids: string[] }
    product_cardLocal AgentWriteThe product card's picture and words (AI).{ action_id }
    profile_changes_listLocal AgentReadChanges on the profile over time: the agent's, the owner's, Google's.{ offset?, limit? }
    profile_field_setLocal AgentWriteChange a basic on the Google profile: phone, website, description, hours, and more (a card the agent applies).{ field, value }
    profile_photosLocal AgentReadThe photos on the profile and the ones waiting.{}
    reference_addLocal AgentWriteAdd a reference photo by its picture address in Fly storage.{ category_id (from references_list), title, reference_role: practitioner | staff | interior | exterior | product | other, description, person_name? (required for practitioner and staff), usage_instructions?, image_url, usage_mode?: reference | ready_to_post }
    reference_removeLocal AgentWriteRemove a reference photo.{ reference_id }
    reference_tagLocal AgentWriteTag a reference photo.{ reference_id, reference_role: practitioner | staff | interior | exterior | product | other, description, person_name? (required for practitioner and staff), usage_instructions? }
    references_listLocal AgentReadThe reference photos and their categories.{}
    save_gbp_attributesLocal AgentWriteSave the attributes (the whole list).{ attributes: [...] }
    save_gbp_servicesLocal AgentWriteSave the services (the whole list as the page sends it).{ services: [{ ... isEnabled }] }
    service_describeLocal AgentWriteA description for one service (AI).{ name }
    service_scheduleLocal AgentWriteAdd services to the profile one at a time, on a schedule or by the agent.{ services, mode, at? }
    service_suggestLocal AgentWriteServices the agent suggests (AI).{ round?: saved | new, exclude?: string[], existing?: string[] }
    undo_changeLocal AgentWriteUndo a change the agent made on Google.{ action_id }
    ads_reportAccountReadThe Ads Agent's work report for a range; its part "proof" (ADS-PROOF-1) is the cost of a result of the owner's goal on the accounts Fly runs against the owner's own ads in the 30 days before Fly's first campaign, per network (not counted, or judged on clicks where the owner chose to run without counting), with the verdict; its part "status" (ADS-STATUS-1, a range to today) is where things stand: the owner's next step and what it unlocks, how many more wait, when Fly's next pass is and what it does there, one line on Fly's own work kept within its allowance where it is tight or over this month (WO-E), and each network in one line.{ from?, to? }
    citations_reportAccountReadThe Listings Agent's work report for a range: where the listings stand, its work, where the business is listed, what needs the owner and what is next.{ from?, to? }
    local_reportAccountReadThe Local Agent's work report for a range.{ from?: YYYY-MM-DD, to?: YYYY-MM-DD }
    performance_rowsAccountReadGoogle performance by day: views, clicks, calls, directions; the search terms.{ days?, terms? }
    report_getAccountReadOne kept report, with its HTML.{ id }
    reports_listAccountReadThe reports kept for the location.{}
    social_reportAccountReadThe Social Agent's work report for a range.{ from?, to? }
    web_reportAccountReadThe Website Agent's work report for a range.{ from?, to? }
    get_review_settingsLocal AgentReadThe review responder settings.{}
    review_generator_createLocal AgentWriteMake the review link and QR code.{}
    review_generator_getLocal AgentReadThe review link and QR code.{}
    review_generator_reviewsLocal AgentReadThe reviews that came through the link.{}
    review_generator_statsLocal AgentReadHow the review QR is doing.{}
    review_generator_updateLocal AgentWriteChange the review link's settings.{ ...settings }
    review_policy_getLocal AgentReadThe agent's reply rules and mode.{}
    review_policy_saveLocal AgentWriteSave the reply rules.{ policy, source? }
    review_queue_decideLocal AgentWriteSend or ignore drafted replies.{ review_row_ids | all_waiting: true, decision: send | ignore }
    review_queue_editLocal AgentWriteEdit a drafted reply.{ review_row_id, draft }
    review_queue_listLocal AgentReadThe reviews waiting for a reply and the replies drafted.{ view?, offset?, limit? }
    review_queue_redraftLocal AgentWriteDraft a reply again (AI).{ review_row_id }
    review_replies_recentLocal AgentReadThe recent replies.{}
    review_reply_refineLocal AgentWriteTell the agent how to change a reply on a card.{ action_id, instruction }
    review_reply_timesLocal AgentReadWhen the reply runs go.{}
    save_review_settingsLocal AgentWriteSave the review responder settings.{ ...settings }
    content_instructionsAccountWriteThe standing instructions for one kind of content: list them, add one, withdraw one.{ kind: frames | posts } | { kind, add: text } | { kind, remove_id }
    instruction_generaliseAccountWriteTurn a refine instruction into a general rule (AI; saves nothing, answers the rule to offer).{ instruction, source: post_refine | frame_refine }
    instruction_rememberAccountWriteKeep a refine instruction as a standing rule.{ instruction, source: post_refine | frame_refine }
    services_onlyAccountWritePosts only about listed services: read it ({}), switch it, or set the services it may post about (null goes back to the Google list).{} | { services_only?: boolean, approved_services?: string[] | null }
    settingsAccountWriteRead the agent settings (no changes) or change them: mode, switches, contacts, posting days.{ changes?: { autonomy?: approve_required | auto_safe | full_auto, enabled?: boolean, enabled_checks?: { <switch>: boolean }, notify_emails?: string[], notify_phones?: string[], content_post_days?: "1,3,5" | null, auto_schedule_posts?: boolean, ... } }
    inbox_draftSocial AgentWriteDraft a reply to an inbox item (AI).{ item_id }
    inbox_hideSocial AgentWriteHide an inbox item.{ item_id }
    inbox_listSocial AgentReadThe social inbox: comments and messages.{ status?: open | replied | hidden | ignored, kind?: comment | message | mention, cursor?, limit?, post_id? }
    inbox_markSocial AgentWriteMark an inbox item ignored or open.{ item_id, status: ignored | open }
    inbox_replySocial AgentWriteReply to an inbox item.{ item_id, text }
    social_allowanceSocial AgentReadThe Social plan's posts and replies this month.{}
    social_captionsSocial AgentWriteEach network's own caption for a post (AI).{ text, networks: string[] }
    social_draft_decisionSocial AgentWriteApprove or reject a social draft; approve with when: now to post at once.{ social_post_id, decision: approve | reject, when?: now }
    social_draft_redrawSocial AgentWriteDraw a social draft's picture again.{ social_post_id, instruction? }
    social_draft_refineSocial AgentWriteRefine a social draft's words (an instruction, or the words per network).{ social_post_id, platforms?, instruction } | { social_post_id, words: { network: text } }
    social_draft_slide_orderSocial AgentWriteReorder a carousel's slides.{ social_post_id, order: string[] }
    social_draft_slide_refineSocial AgentWriteRedraw one slide with an instruction.{ social_post_id, slide, instruction }
    social_draft_whenSocial AgentWriteMove a social draft to a time, or post it now.{ social_post_id, scheduled_at } | { social_post_id, when: now }
    social_draftsSocial AgentReadThe Social Agent's drafts.{}
    social_post_reply_settingsSocial AgentWriteAuto-reply on or off for a post (or as the account), and its reply instructions.{ social_post_id, reply_mode?: on | off | account, reply_instructions? }
    social_post_retrySocial AgentWriteTry a post again on one network.{ social_post_id, platform }
    social_post_statusSocial AgentReadHow a post went on each network.{ social_post_id }
    social_reel_brief_emailSocial AgentWriteEmail the week's reel brief to the creator (the reel brief card's id).{ action_id, email }
    social_targetsSocial AgentReadThe networks a post may also go to.{}
    social_timelineSocial AgentReadThe posts that went live across networks in the last 90 days, with their numbers.{}
    social_video_settingsSocial AgentWriteVideos a week, Stories, carousels, text posts and the reel voice (read with none of them).{ social_videos_per_week?: 0 | 1 | 2 | 3, social_stories?: boolean, social_carousels?: boolean, social_text_posts?: boolean, social_reel_voice?: boolean }
    tiktok_creator_infoSocial AgentReadTikTok's creator choices before a direct post.{ account_id, media: video | photo }
    ai_visibility_proposeWebsite AgentWritePropose AI questions to track (AI).{}
    ai_visibility_resultsWebsite AgentReadThe week's answers on four AI engines.{ week? }
    ai_visibility_saveWebsite AgentWriteSave the questions tracked.{ prompts: [{ id?, text, active }] }
    article_anotherWebsite AgentWriteSuggest another article on an article card.{ action_id }
    blog_saveWebsite AgentWriteSave an article, now or for a day.{ id?, title, body, at?, ai? }
    blog_topicsWebsite AgentWriteArticle topics for the business (AI).{}
    blog_unscheduleWebsite AgentWriteTake an article off its day.{ id }
    blog_writeWebsite AgentWriteWrite an article on a topic (AI).{ topic }
    blogs_listWebsite AgentReadThe Fly site's articles: published, scheduled, drafts.{}
    domain_checkWebsite AgentReadIs a domain available.{ name }
    domain_contactWebsite AgentReadThe contact fields a domain order needs.{ name }
    domain_proposeWebsite AgentReadDomain names proposed for the business.{ page? }
    domain_stateWebsite AgentReadDomains: the site, the plan, the names held.{}
    domain_transfer_codeWebsite AgentWriteThe transfer code of a domain Fly bought.{ domain }
    site_previewWebsite AgentReadA screenshot of a page.{ url }
    web_ai_competitorsWebsite AgentReadWho AI answers name beside the business.{ range?: 4w | 12w | 26w | 52w }
    web_ai_discovery_getWebsite AgentReadThe month's AI search read.{ month?: YYYY-MM }
    web_ai_overviewWebsite AgentReadAI search visibility: the overview.{ range?: 4w | 12w | 26w | 52w }
    web_ai_planWebsite AgentReadThe month's AI visibility plan.{ month?: YYYY-MM }
    web_ai_prompt_getWebsite AgentReadOne prompt's answers over time.{ prompt_id, range?: 4w | 12w | 26w | 52w }
    web_ai_prompt_saveWebsite AgentWriteAdd, change, pin or remove a prompt.{ prompt: { id?, text?, active?, pinned?, remove? } }
    web_ai_promptsWebsite AgentReadThe AI prompts tracked.{ status?: tracked | paused | retired | all, source?: proposed | owner | import | discovered, engine?: chatgpt | perplexity | gemini | google_ai | copilot, q?, sort?: volume | share | newest | az }
    web_ai_prompts_importWebsite AgentWriteImport prompts (a preview unless dry_run is false).{ items: string[], dry_run?: boolean }
    web_ai_sourcesWebsite AgentReadThe sources AI answers cite.{ range?: 4w | 12w | 26w | 52w }
    web_ai_todo_section_doneWebsite AgentWriteMark a plan section done.{ action_id, plan_id }
    web_article_cancelWebsite AgentWriteCancel a scheduled article.{ action_id }
    web_article_prepareWebsite AgentWritePrepare the owner's own article for publishing.{ title, body, search?, picture_url?: url | none, seo_title?, description?, target?: fly | cms, polish?: boolean }
    web_article_publishWebsite AgentWritePublish it, now or at a time: send the same words and choices again (the prepared answer is not read back).{ title, body, search?, seo_title?, description?, picture_url?: url | none, target?: fly | cms, kind?: own | polished, source?: written | upload, file_name?, when?: ISO | now }
    web_articles_listWebsite AgentReadThe articles the Website Agent published, and the ones scheduled.{}
    web_cms_changeWebsite AgentWriteChange content on the owner's own connected site (WordPress, Ghost, Drupal, Magento, PrestaShop): the agent reads the page, makes only the change asked, writes it back and keeps Undo.{ instruction, page?: { remote_id? | url? } }
    web_cms_change_statusWebsite AgentReadHow the changes asked for on the owner's own site are going: the newest 10, or one, with what was done and whether Undo is offered.{ action_id? }
    web_cms_connectWebsite AgentWriteConnect the owner's own site (a CMS; Blogger signs in through Google in the app).{ kind: wordpress | shopify | wix | webflow | joomla | drupal | hubspot | ghost | duda | bigcommerce | magento | prestashop | contentful | strapi, fields: { site_url, login?, secret, ... } }
    web_cms_disconnectWebsite AgentWriteDisconnect the owner's own site.{}
    web_cms_kindsWebsite AgentReadThe CMS kinds the Website Agent can connect.{}
    web_cms_page_getWebsite AgentReadOne page of the owner's own connected site as the site keeps it: its HTML (cut at 60 KB), title, excerpt and search title.{ remote_id? | url? }
    web_cms_pagesWebsite AgentReadThe pages of the owner's own connected site (its own pages, not its posts), with their ids and addresses; unsupported where the kind lists none.{}
    web_cms_statusWebsite AgentReadThe owner's own site connection.{}
    web_code_connectWebsite AgentWriteConnect a custom-built site's repository.{ repo, access_token }
    web_code_disconnectWebsite AgentWriteDisconnect the repository.{}
    web_code_statusWebsite AgentReadA custom-built site's GitHub connection.{}
    web_google_connect_startWebsite AgentWriteStart connecting the owner's Google.{ kind: gsc | ga4 }
    web_google_connect_statusWebsite AgentReadWhere that connection stands; with_resources lists the properties web_google_pick takes.{ kind: gsc | ga4, with_resources?: boolean }
    web_google_disconnectWebsite AgentWriteDisconnect the owner's Google.{ kind: gsc | ga4 }
    web_google_pickWebsite AgentWritePick the property or stream.{ kind: gsc | ga4, resource_ref }
    web_google_stateWebsite AgentReadThe owner's own Google (Search Console, Analytics) connection.{}
    web_insights_getWebsite AgentReadSearch Console and GA4 readings for the sites.{}
    web_insights_source_addWebsite AgentWriteAdd a Search Console or GA4 source.{ kind: gsc | ga4, property, site? }
    web_insights_source_removeWebsite AgentWriteRemove a source.{ source_id }
    web_insights_source_testWebsite AgentWriteTest a source.{ source_id }
    web_interview_answerWebsite AgentWriteAnswer them (no interview_id: the newest open one).{ interview_id?, answers: [{ question_id, text, via?: typed | voice }], photos?: url[], allow_quote?: boolean, allow_name?: boolean, owner_name? }
    web_interview_getWebsite AgentReadThe questions for an article short of material.{ interview_id? }
    web_market_getWebsite AgentReadThe market and the data the agent uses.{ month?: YYYY-MM }
    web_rank_getWebsite AgentReadWhere the website ranks on Google, by week.{}
    web_rank_keywords_setWebsite AgentWriteAdd searches to track for the website (ten at a time at most) or remove them by their ids from web_rank_get.{ add?: string[], remove?: keyword_id[] }
    web_search_workWebsite AgentReadWhat the agent did with the weekly search read.{}
    web_seo_changesWebsite AgentReadWhat the agent changed for search and the 28-day result.{}
    web_visitors_getWebsite AgentReadThe Visitors report (Fly's own analytics).{ range?: 7 | 28 | 90 }
    website_buildWebsite AgentWriteAsk for a Fly website.{}
    website_changeWebsite AgentWriteAsk for a change on the Fly website (counts on the trial).{ instruction }
    website_change_statusWebsite AgentReadHow a website change is going.{ action_id? }
    website_checkWebsite AgentReadThe latest website check and its recommendations.{}
    website_developer_getWebsite AgentReadThe developer handover email.{}
    website_developer_sendWebsite AgentWriteSend the developer handover email (the website check card's id), or an Ads tracking tag card's tags to the web developer (ads_pixel_install, ads_conversion_tag; ADS-DEVMAIL-1).{ action_id, emails: string[], note?, auto_send?: boolean }
    website_domain_connectWebsite AgentWriteConnect a domain through its provider.{ domain, method: domain_connect | entri, return_path }
    website_domain_instructionsWebsite AgentWriteEmail the DNS steps for a domain.{ domain, emails: string[] }
    website_domain_setupWebsite AgentWriteThe steps page for the owner's own domain.{ domain? }
    website_domain_watchWebsite AgentWriteWatch a domain until it points at the site.{ domain, method?: domain_connect | entri }
    website_look_setWebsite AgentWriteChange the look.{ look: front-page | marquee | workshop | lantern | signboard }
    website_looksWebsite AgentReadThe looks a Web plan site may wear.{}
    website_photosWebsite AgentWriteSend photos for the website.{ photos: [{ url }] }
    website_preview_getWebsite AgentReadThe private preview of a free site on the Web plan.{}
    website_preview_startWebsite AgentWriteStart that preview.{}
    website_version_previewWebsite AgentReadOne version's HTML.{ version_id }
    website_version_restoreWebsite AgentWritePut a version back.{ version_id }
    website_versions_listWebsite AgentReadThe website's kept versions.{}

    Tools

    Run one with POST /v1/tools/{tool}, its arguments as the JSON body. A tool that works on a location takes location_id in its body.

    Each description is the tool's own, as GET /v1/tools answers it, written for AI assistants. Where one names fly_use_location, the API keeps no current location: send location_id instead.

    Tools
    ToolWhat it doesArguments
    fly_whoamiThe person behind this connection, its scopes, its access (the workspaces, locations and agents it may reach; all where it is not held to some) and the location this session works on: none until fly_use_location picks one in this session.none
    fly_list_workspacesEvery workspace and location this connection may reach that runs the agents, with the location ids, names, the agents on at each and the agent state, whether the MCP may work there (a paid plan or a grant), and the connection's access. Workspaces and locations outside its access are not listed.none
    fly_homeThe agent home for the location: the business, the cards that need the owner, cards in flight, recent activity, rank, health signals, the plan and what is switched on. With agent, the cards and the activity of that agent only; all (the default) for every agent.location_id, agent
    fly_cardOne card from fly_home with every detail the page shows (the proposed words, the picture, the inputs it asks for), by its action_id.location_id, action_id
    fly_card_respondApprove, decline, mark done, dismiss, submit (with inputs) or undo a dismiss on a card from fly_home.location_id, action_id, decision, reply_text, inputs
    fly_activityThe activity trail of the agent at the location, newest first, a page at a time.location_id, offset, limit
    fly_runsThe passes the agent ran at the location, newest first, with what each did.location_id, limit, before
    fly_run_nowQueue an agent pass now, every stage or the named ones (for example ["reviews"], ["content_weekly"], ["seo"]; ["ads_daily"] for the Ads Agent). Fly may refuse on demand runs for this account; the answer says so.location_id, checks
    fly_askAsk the agent a question about this location (reviews, rank, posts, what it did). Read only: it answers from what it knows and never acts. Each question stands alone, so put what it is about in it. complete false means the answer stopped short even after asking again: ask a narrower question.location_id, question
    fly_instructOne of three: instruction tells the agent something in plain words (a standing rule such as "never mention prices", a one-off job such as "write a post about our Diwali hours", or a change to the website; the agent routes it and says what it did); retire_id retires a standing rule; list: true lists the standing rules with their ids. To retire a rule, list first and pass its id as retire_id: never send a request to retire, remove or stop a rule as an instruction, it would be saved as a new rule.location_id, instruction, retire_id, list, agent
    fly_reportThe work report of one agent for a date range: the Local Agent (Google profile), Social, Ads or Website Agent. Shaped for an assistant: the period, the headline numbers, each section's words, the first 10 rows of each table and the newest 10 lines of work and things made, with their totals. The full report page is a link from fly_report_links.location_id, agent, from, to
    fly_performanceGoogle Business Profile performance by day: search and maps views, website clicks, calls, directions; the month's search terms when asked. With no rows, note says why (no Google profile connected, or Google has not reported yet).location_id, days, terms
    fly_calendarThe whole content calendar for a range of at most 62 India days, merged by day, each entry with its source: local is the Local Agent's (Google posts, the agent's drafts, booked and approved posts); social is the Social Agent's (posts that went out on the networks, and posts booked, planned or going out there). Under a connection without the Local Agent or without the Social Agent, that agent's half is left out and the answer says so.location_id, from, to
    fly_draftsThe drafts waiting for the owner's review, each with its source: local is the Local Agent's post drafts with their words and pictures (fly_idea_decide, fly_idea_feedback); social is the Social Agent's drafts waiting for a decision (fly_agent_op social_draft_decision, social_draft_when). Under a connection without the Local Agent or without the Social Agent, that agent's half is left out and the answer says so.location_id
    fly_post_writeThe agent writes a Google post from a brief, or tightens a draft you give it. Returns the caption and whether it read your text as a brief or a draft. Nothing is posted.location_id, text, post_type, rewrite
    fly_post_createMake a Google post with these words now, or at scheduled_at (ISO 8601); with media_urls for pictures; to the connected social networks too with social_targets (to_google: false for the networks alone). Check fly_calendar first so a post is not booked twice. The answer's post_id moves or cancels it before it goes out (fly_post_reschedule, fly_post_cancel).location_id, summary, type, media_urls, scheduled_at, call_to_action, event_info, offer_info, social_targets, to_google
    fly_post_cancelCancel a post made with fly_post_create (or on the New post page) that has not gone out: its Google post and its social posts, by the post_id fly_post_create answered (or the social_post_id of one of its social posts). A post that is live or going out is refused; a post the agent wrote from a draft is cancelled with fly_agent_op idea_withdraw (mode cancel) instead.location_id, post_id
    fly_post_rescheduleMove a post made with fly_post_create (or on the New post page) that has not gone out to a new time, ten minutes ahead at least: its Google post and its social posts together. A post the agent wrote from a draft moves with fly_idea_reschedule instead.location_id, post_id, scheduled_at
    fly_idea_decideApprove a draft from fly_drafts (source local) or reject it. With scheduled_at (ISO 8601, two hours ahead at least) an approved draft goes out then; without it the agent picks the time.location_id, idea_id, decision, scheduled_at
    fly_idea_feedbackTell the agent what to change on a draft: the words, the picture or both. A new version follows in a minute or two.location_id, idea_id, feedback, target
    fly_idea_rescheduleMove a scheduled or approved draft to a new time (ISO 8601, at least two hours ahead).location_id, idea_id, scheduled_at
    fly_settingsRead the agent's settings at the location (no changes), or change them: the mode (suggest_only, approve_required, auto_safe, full_auto; a move up may need the app), the switches (enabled_checks: reviews, content, photos, seo, social_agent, ads_agent, web_agent and more), where alerts go (notify_emails, notify_phones), posting days.location_id, changes
    fly_ai_creditsThe Fly AI credits of the workspace the location is in, which pay for what Fly AI does when asked. get: the balance, this month's free allowance and auto top-up; ledger: the changes, newest first; topup_link: the Billing page link where the owner buys a block (nothing is bought here); autotopup_get; autotopup_set: on or off, the threshold and the block in minor units (on needs a card or UPI already saved on the Billing page, else the answer gives the link to save one).location_id, action, on, threshold_minor, block_minor, limit, before
    fly_creditsEvery balance of the workspace the location is in, and its auto top-up. get: the Fly AI credits, the Content agent balance where it is open, and each auto top-up; topup_link: the Billing page link where the owner buys a block of kind fly_ai_balance or content_balance (nothing is bought here); autotopup_set: kind, on or off, threshold_minor, block_minor (on needs a card or UPI already saved on the Billing page). Plans, cancelling and payment methods stay in the app.location_id, action, kind, on, threshold_minor, block_minor
    fly_ai_settingsFly AI's settings for the person behind this connection. get: the settings and the models Fly AI offers with their prices per million tokens in dollars and the rupee rate; or set any of default_location_id and default_agent (where a new Fly AI chat starts; an empty string clears one), confirm_writes (whether Fly AI asks before it changes anything), model (the model a reply runs on; an empty string goes back to the default, Sonnet 5.5), effort (low, medium or high), max_tool_calls (the most tool calls one reply makes, 1 to 100, 50 by default; more lets a reply do more and costs more) and turn_spend_cap_minor (the most one reply may spend, in minor units; 0 is no cap).location_id, action, default_location_id, default_agent, confirm_writes, model, effort, max_tool_calls, turn_spend_cap_minor
    fly_ai_whatsappThe WhatsApp numbers that reach Fly AI for the person behind this connection. list: the numbers, the account's verified phone among them; add: a 6 digit code goes to the number (the account's verified phone needs none); verify: the number's id and that code; remove: the number's id. A number reaches Fly AI for every workspace, location and agent, so add works only on a connection given all of them.location_id, action, phone, id, code
    fly_read_pageRead one web page by its address (https; an http address is read as https) and answer its words: url, final_url (after redirects), title, chars_total, chars_returned, truncated and text (the title, headings, paragraphs, list items, table cells and link words with their addresses; scripts, menus and footers left out; a PDF's words when it is one). text is cut at max_chars on a sentence boundary; truncated true means the page has more than text holds, so say so. A page that does not answer, answers an error or is not a page answers error and why. Reads only; private network addresses are never read and no login is ever sent.url, max_chars
    fly_ops_catalogThe ops fly_agent_op may run, with their family, whether they read or write, what they do and the params they take. Filter by family.family
    fly_agent_opRun any op from fly_ops_catalog on the location with its params (an object). This is how everything without a tool of its own is done: reviews, keywords, the profile, the website, social, ads, citations, bookings, business knowledge.location_id, op, params