Start here. Lists every tracked project (id, store, kind, markets, keyword and top-10 counts, searches checked vs never checked, audit step, last check), folders, running and recently finished jobs, key settings, license state and unread rank alerts. Use the ids it returns with every other tool.

Keyword x market grid for one project, summarised per market: for each keyword its id, label, row summary and, per shown market, rank / previous rank, ESTIMATED volume & difficulty (estVol/estDiff), REAL popularity (pop, only when a provider is connected), verdict and opportunity. Also the top competitors. With more than 4 tracked markets only the main market is shown unless you pass markets. Hidden keywords are excluded unless section is hidden/all.

Everything about one keyword in one market: the current cell (rank, estimates, real popularity, verdict), rank/estimate history by day, and the apps currently ranking for it (position, rating count, installs, whether the phrase matches their title/subtitle).

Markets (countries) available for a store with search language, listing locales and a 0-10 potential score. Use the country codes as market ids.

Status of the local AI providers the app uses for brainstorming, suggestions, the optimizer and the assistant: installed / signed in / ready, current model and the next setup step when not ready.

Which REAL popularity sources (Apple Ads, Google Ads Keyword Planner, imported files) are connected, for which store, and when they last fetched. Credentials are never returned.

Rank-change alerts raised by checks (keyword, market, from -> to rank), newest first.

Listing optimizer state for a project: step, current live listing, generated listing options (with reach/difficulty, covered phrases and validation problems), the chosen option, core phrases and per-locale drafts with translation candidates. Descriptions are cut unless full is true.

Before publish_listing: reads the live listing fresh from App Store Connect / Play Console and returns, per language the publish writes, each field it changes as from -> to, isNew for a language the app does not have yet, and the languages that already match (unchanged). source is console (fresh read) or stored (no console answered). Tell the owner what changes before publishing.

Where the app stands, 0-100, per tracked market and overall (markets weighted by potential): rankings (share of searches its ranks would get, weighted by demand), listing (how much of the demand its name / subtitle / keyword field can catch), competition (how beatable the phrases it does not lead are), a verdict (strong / steady / needs_work), up to 6 takeaways per market (gap: high demand ranked low; uncovered: listing misses a phrase with demand; beatable: easy and not top 10; hold: top 3 to protect) and the daily total history. Demand is real popularity when connected (demandSource). Use it to pick the next optimizer or keyword step.

The project's screenshot design: slides (heading in the main locale, image per device), theme, headings per locale, render status per locale/device/slot, and checks (errors block export and upload: missing images, headings over the limit, stale or missing translations, low text contrast). Edit headings with screenshots_write_headings / screenshots_translate; images, rendering, export and upload are done in the app.

What people search in one App Store market around a seed word, from the store's own autocomplete (suggestions are ordered by search volume): the seed, the seed plus a space and plus common next letters are asked and merged in order of first appearance (position 1 = most searched). tracked marks phrases already in the project. Google Play answers supported:false (no public source). Good for finding high-demand phrases to add with add_keywords.

The app's average rating and rating count per market over the last days (recorded after each rank check; App Store per storefront, Google Play global): latest values, ratings added over the range (newRatings), change of the average (ratingChange) and the daily points.

How well the estimated volume tracks real popularity, over every tracked phrase that has both (Apple Ads / Google Ads / imported): pairs, spearman rank correlation (-1..1, null under 10 pairs), meanAbsError on 0-100 and bandAgreement (share in the same low/medium/high band). Use it to judge how far to trust estimates where real popularity is missing.

Name and subtitle changes of tracked rivals (kind competitor), noticed when their listing is re-read (every rank check), newest first: app, locale, field (title or subtitle), from -> to, read. A rival renaming around a phrase is a signal to re-check that phrase.

For App Store ids (e.g. competitors from get_board) in one store: first release date, date of the current version, version, price, rating count and ratings per day since release (how fast the app gathers reviews; a fresh update and high ratings/day mean an active rival). Google Play answers an empty list (its page has no reliable dates). Ids missing from the answer are not in that store. At most 50 ids.

The editable app version on the developer console (if any) and the version string the app would suggest for publishing.

Connected developer console accounts for a store (App Store Connect / Google Play Console) and the apps they can see, with whether each app is already tracked.

Live store search in one market (10 apps unless limit asks for more: up to 200 on the App Store; Google Play returns about 30 at most). Accepts a search term or a pasted store URL. Apps already tracked carry trackedAs {projectId, kind}. Use it to find app ids before add_app.

Recent messages of the in-app ASO assistant for a project (keywords or optimizer scope), including keywords it mentioned and the changes it proposed with their status (proposed / applied / dismissed / failed).

Start tracking an app as a project: your own app (kind mine) or a competitor. Accepts an App Store / Play id, bundle / package name or store URL (find it with search_store). Imports the live listing and seeds keywords in the background; the new project appears in get_overview when the job finishes.

An app idea (a brainstorm project, no store app yet) is now published: link it to its App Store id / Play package / store URL. It becomes kind mine (or competitor), keeps every keyword and history, and the store listing replaces the idea's name. Fails for projects that already have an app or when the app is already tracked.

Track every app visible in the connected developer console account(s) for a store as 'mine' projects (skips ones already tracked).

Create a brainstorm project for an app that does not exist yet: the AI proposes keywords from a short brief and checks them in the chosen markets. Requires a ready AI provider.

Rename a project, change its brief (context used by the AI) or its automatic rank-check schedule.

Replace the list of markets (countries) tracked for a project. New markets are empty until run_rank_check runs for them.

Move a project into a folder (null = top level), optionally placing it before another project.

Permanently delete a project with its keywords, rank history and optimizer drafts. Only when the owner asked for this exact project: pass its name (from get_overview) as confirmName; a mismatch deletes nothing.

Re-import the app's live listing / metadata from the store (and console when connected).

Create a folder (omit folderId) or rename an existing one.

Delete a folder. Its projects are kept and move to the top level.

Add one or more keywords (search phrases) to a project. section 'listing' = phrases the listing targets now; 'idea' = candidates to evaluate (default). localize=true asks the AI to translate each phrase into every tracked market's search language (otherwise the same phrase is used everywhere). New keywords have no ranks until run_rank_check.

Rename a keyword and/or hide it (hidden keywords stay tracked but leave the active board) or unhide it.

Permanently delete keywords and their rank history. Prefer edit_keyword hidden:true unless the owner wants them gone.

Have the AI translate a keyword into the search language of each market (or the given markets), replacing non-overridden per-market phrases.

Ask the AI for new keyword ideas for a project based on its listing, brief and current board; they land in the 'idea' section.

Override the exact search phrase used for a keyword in one market (e.g. a better local wording). An empty phrase removes the override.

Search the store for every keyword in the project's markets and record ranks, estimated volume/difficulty and competitors. Runs as a background job (the store is rate-limited, so large boards take minutes). Results already checked today are reused unless force is true.

Pull REAL search popularity for the project's keywords from the connected source (Apple Ads popularity or Google Ads Keyword Planner). Separate from rank checks and from ASOMaster's estimates; requires a connected source (get_popularity_status).

Start the listing optimizer for a project: scouts the board's keywords in the main locale and has the AI write several complete listing options (title, subtitle/short description, keyword field, description) scored for reach and difficulty. Replaces previous options. Background job; then read get_optimizer.

Have the AI write the one-line heading printed on each screenshot slide, in the main locale (verb first, one benefit, at most 34 characters; 40 for scripts without case). Slides that already have a heading are kept unless overwrite is true or slideId names one slide. Background job; then read get_screenshots. Slides and images are set up in the app.

Adapt the main screenshot headings to the project's other languages (or only locales), reusing each language's own search words. Every slide needs a main heading first. Background job; then read get_screenshots (locales show translated / stale / missing). Rendering and upload happen in the app.

Generate additional listing options next to the existing ones.

Add your own listing option (omit optionId) or replace the listing of an existing option. The app re-scores it and reports validation problems (length limits, repeated words) in get_optimizer.

Set What's New and the listing links written by the next publish. Apple: whatsNew, marketingUrl, supportUrl, privacyUrl for the main language (or every published language with allLanguages). Google Play: marketingUrl is the contact website, plus contactEmail. Omitted fields stay; empty strings clear. publish must be true for publish_listing to write them. Links must start with https://.

Delete one listing option (generated or custom) from the optimizer.

Pick the listing option to ship and the core phrases it must carry into every locale. Next step: optimizer_localize.

Write per-locale drafts of the chosen listing: the core phrases are translated, candidate local phrasings are measured in each locale's test market, and the best are used. A locale that fails does not stop the others; get_optimizer lists failedLocales and lastError. Background job.

Change fields of one locale's draft listing (empty string clears a field).

In one locale draft, use a different measured candidate phrase for a core phrase (from that locale's candidates in get_optimizer).

Discard all options, the choice and every locale draft for the project.

DESTRUCTIVE / LIVE: pushes the chosen listing and every ready locale draft to App Store Connect or Google Play Console, changing what real users see. Only call after the owner has reviewed the exact listing text and explicitly told you to publish in this conversation; never on your own initiative and never as part of a larger plan they approved in general terms. Requires a connected console. The app then shows the owner a confirmation dialog listing the store, app, version, locales and fields; nothing is published unless they click Publish there (no answer within ~2 minutes = denied, error code not_approved). Background job once approved; follow with wait_for_jobs and report the outcome.

Connect an App Store Connect API key (apple: keyId, issuerId, private key .p8) or a Google Play service account (google: service-account JSON, optional package names). Pass FILE PATHS (privateKeyPath / serviceAccountPath; files must be .p8/.pem/.json/.txt in the owner's Downloads, Desktop or Documents folder) so secrets never enter the conversation; the bridge reads them locally and the app stores them in the OS keychain. Credentials are never returned. Needed for console apps, publishing and own-app metadata.

Verify a connected console account still works (updates its status in list_console_apps).

Remove a console account and delete its stored key from the keychain. Ask the owner first.

Connect a source of REAL keyword popularity: apple_ads (Apple Ads API: clientId, teamId, keyId, private key, optional orgId), google_ads_planner (Google Ads Keyword Planner: developerToken, customerId, refreshToken, oauthClientId, oauthClientSecret, optional loginCustomerId) or imported (a popularity export file at filePath). Prefer file paths for keys. Secrets go to the OS keychain and are never returned. Then call fetch_popularity.

Disconnect a popularity source and delete its stored credentials. Ask the owner first.

Change app settings; only the keys you pass change. Use set_ai_provider for the AI provider/model.

Select the local AI provider (and optionally model) the app uses for generation. Check readiness with get_ai_status first.

Send a tiny test prompt through a provider and record latency / errors (see get_ai_status). Refused for providers that bill an API key; the user runs those tests in the app.

Mark rank alerts as read (given ids, or all when ids is omitted). With clear:true, delete all alerts instead.

Import an Astro export or a CSV of apps / keywords from a local path (must be a .csv/.tsv/.txt/.json file in the owner's Downloads, Desktop or Documents folder). format astro without path reads Astro's own database on this Mac: its popularity becomes real popularity and each Astro app's phrases join the tracked app with the same App Store id. previewOnly:true just reports what would be imported (rows, apps, keywords, countries). With projectId the phrases are added as keywords of that project; otherwise apps become projects (optionally in folderId). Background job.

Export a project's board, rank history or optimizer drafts as CSV or JSON. By default returns the content (cut at maxChars); with saveToFile:true writes the file into the app's exports folder instead. format fastlane (what optimizer only) always writes a zip of fastlane deliver / supply metadata to the exports folder.

Send a message to the in-app ASO assistant for a project (keywords or optimizer scope). It PROPOSES keyword / listing changes (status proposed) but applies nothing by itself; review them with the owner, then call apply_assistant_changes or dismiss_assistant_changes. Background job; read the reply with get_assistant_thread after wait_for_jobs.

Apply changes the assistant proposed in one of its messages (ids from get_assistant_thread, e.g. "c0"; omit changeIds for every still-proposed change). Already applied or dismissed changes are skipped. Only apply what the owner agreed to.

Mark changes the assistant proposed in one of its messages as dismissed (omit changeIds for every still-proposed change). Nothing in the project changes.

Delete the assistant conversation history of a project.

Stop a queued or running background job (rank check, AI generation, import, ...). Work already done is kept.

Remove finished, failed and stopped jobs from the job list. Queued and running jobs are kept; their results (rankings, options, ...) are not affected.

Block until background work changes state: returns as soon as a job finishes (done / failed / stopped), or when nothing is queued or running, or after timeoutSeconds (max 50). With jobId, waits for that job only; with projectId, for that project's jobs. Call it repeatedly after any tool that queued work until idle is true, then read the results. Reports progress of jobs still running.