MetaRun

View saved version →

---
name: ai-visibility
description: >-
  Find out whether AI assistants recommend an iOS app, why rivals get named
  instead, and which web sources shape those answers, then turn the gaps into
  listing and keyword work. Use for "does ChatGPT recommend my app", "why
  does AI suggest my competitor", "how do I get recommended by AI", "AI
  visibility".
---

# AI visibility: measure, diagnose, act

## Measure

`check_ai_visibility` works on any App Store app without an account. It asks a
search-grounded answer engine three questions a real person would ask, then
scores whether the app is named and recommended. Pass `niche` (for example
"habit tracker") when the store category is broader than the app really is;
a wrong category produces a misleading score. Say which engine was asked; it
is not ChatGPT itself.

With a linked account, `aeo_visibility_report` shows the person's tracked
questions over time.

## Diagnose

Read the result honestly:

- Named but not recommended: the engine knows the app but other pages argue
  better for rivals.
- Not named: the app is missing from the sources the engine reads.
- The sources list is the lever: those are the pages that decide the answer.

## Act (what MetaRun can and cannot do)

MetaRun measures and diagnoses. It never posts, publishes, sends messages, or
writes reviews anywhere, and neither should you on the person's behalf. What
it can change is the person's own listing:

- Make the App Store listing state the niche plainly (App Store listings are a
  major source for these answers): subtitle and description through the
  localize-listing flow.
- Check keyword ranks for the same phrases with `aso_check_rank` and find
  phrasing people search with `aso_suggest_keywords`.

Everything else (getting covered by the sites in the sources list) is work the
person does themselves; give them a short, concrete list.

View saved version →

---
name: get-started
description: >-
  First steps with MetaRun in ChatGPT for iOS developers: what works right
  away without an account (worldwide pricing, storefront language audit, AI
  visibility check on any App Store app), how to connect a MetaRun account,
  and how change cards work. Use when someone asks what MetaRun can do, how to
  connect it, or how applying a change works.
---

# Getting started with MetaRun

MetaRun runs an iOS developer's App Store presence: listing copy in every
language, prices in every storefront, releases, review replies, keyword ranks,
and whether AI assistants recommend the app.

## Works immediately, for any app, no account

Offer these first: they show value before anyone signs in.

- `calculate_worldwide_prices`: a base price and a strategy (purchasing power
  parity, Big Mac, Spotify, or plain conversion) priced for every App Store
  storefront. Ask for the base price if the person has not given one; never
  pick it for them.
- `audit_storefront_languages`: which countries see a listing in a language
  people there cannot read, and where translated text sits on untranslated
  screenshots. Works on competitors too.
- `check_ai_visibility`: whether an answer engine names and recommends the app
  for the questions people actually ask, who it recommends instead, and which
  sources shaped the answer.

## With a MetaRun account

When a tool needs the person's own apps, ChatGPT shows a button to connect
MetaRun. They sign in on metarun.dev and choose read-only or "prepare changes
you approve". Their App Store Connect key stays encrypted on MetaRun and is
never shared with ChatGPT. Never ask for keys, passwords or tokens in chat.

If MetaRun says no App Store Connect key is connected, relay the link it gives;
the key is added on metarun.dev, not here.

## How changes happen

Every change is two steps, and the second one belongs to the person:

1. You call a preview tool (for example `apple_preview_set_promotional_text`).
   MetaRun reads the live store and shows a change card with the exact before
   and after.
2. The person presses Apply on the card. You cannot apply anything yourself.

So: never say a change is done until the card says it applied. If the card
reports the store changed or the preview expired, call the same preview again.
Every applied change lands in MetaRun's history; `history_search` finds it and
`apple_preview_revert_change` prepares an undo.

## Good first prompts to suggest

- "What should my $4.99 app cost in India, Brazil and Germany?"
- "Which countries see my listing in the wrong language?"
- "Do AI assistants recommend my app when people ask for a habit tracker?"
- "Translate my App Store listing into German and Japanese."
- "Is my next version ready to submit? What blocks it?"

View saved version →

---
name: localize-listing
description: >-
  Translate or rewrite an App Store listing in one or many languages through
  MetaRun: name, subtitle, description, keywords, What's New and promotional
  text. You write the copy; MetaRun checks limits, shows one change card for
  every language, and applies it when the person presses Apply. Use for
  "translate my listing", "add German", "localize my App Store page", "rewrite
  my subtitle", "update What's New in every language".
---

# Localize the listing: you write it, MetaRun ships it

## 1. Read before writing

- `apple_list_apps` to resolve the app (use the bundle id after that).
- `apple_list_app_metadata` for the current copy in every language.
- `apple_get_listing_coverage` to see which languages and fields are missing.
- New language? `apple_list_supported_locales` gives the exact App Store codes
  (for example `de-DE`, `ja`, `pt-BR`, `zh-Hans`).
- A field reported as locked: `apple_get_listing_editability` explains why
  (name, subtitle and description change only while a version is being
  prepared; promotional text can change any time).

## 2. Write the copy yourself

- Translate from the primary language with the app's tone; keep brand names.
- Apple's limits are hard: name 30 characters, subtitle 30, keywords 100,
  promotional text 170, description 4000. Count before staging.
- Keywords are comma-separated without spaces and should not repeat words
  already in the name or subtitle. `aso_lint_metadata` checks a draft.
- What's New only exists on updates; skip it for a first release.

## 3. One card for everything

Call `apple_preview_import_fastlane_metadata` ONCE with every language:

    { "bundleId": "com.example.app",
      "metadata": {
        "de-DE": { "subtitle": "...", "keywords": "...", "description": "..." },
        "ja":    { "subtitle": "...", "keywords": "..." } } }

Field keys: `name`, `subtitle`, `description`, `keywords`, `whatsNew`,
`promotionalText`, `supportUrl`, `marketingUrl`, `privacyPolicyUrl`.
Unchanged fields are skipped, over-limit or locked ones come back as
warnings, and nothing is ever cleared.

For a single field in one language, `apple_preview_set_version_localization`
(description, keywords, What's New), `apple_preview_set_app_info_localization`
(name, subtitle) or `apple_preview_set_promotional_text` also work.

## 4. Let the person apply, then verify

Tell them to review the card and press Apply. Promotional text on a live app
goes public the moment it applies; say so. After they apply, check
`apple_get_listing_coverage` again before saying every language is done.

View saved version →

---
name: release-check
description: >-
  Check whether an iOS version is ready for App Review, explain what blocks
  it, fix what MetaRun can stage, and submit when the person approves. Also
  explains an App Review rejection. Use for "is my app ready to submit", "why
  is Submit greyed out", "ship 2.4", "attach the new build", "Apple rejected
  my app, why".
---

# Release check: from "is it ready?" to submitted

## 1. Find the version and the build

- `apple_list_apps`, then `apple_list_versions`: the editable version is the
  one being prepared (or a rejected one, which stays editable).
- No editable version: `apple_preview_create_version` stages one (Apple allows
  only one at a time).
- `apple_list_builds` lists uploaded builds; `apple_preview_set_version_build`
  attaches one. Builds come from Xcode or CI; MetaRun does not upload them.

## 2. Run the readiness sweep

`apple_preview_submit_for_review` is the sweep. Its card lists every blocker:
version state, missing build, export compliance, App Privacy, empty required
fields per language, and what App Review already holds. Explain blockers in
plain words and stage the fixes MetaRun can make (listing fields through the
localize-listing flow, the build through `apple_preview_set_version_build`).
App Privacy answers are published in App Store Connect itself; say so.

## 3. Submit only on the person's click

When nothing blocks, the card offers Submit for review with a confirmation
checkbox. Only the person can tick it and press Submit. Do not describe the
version as submitted until the card says so.

## After a rejection

`apple_list_review_submissions` shows App Review history newest first,
including the guideline Apple cited. Explain the verdict, help fix the cause,
then run the sweep again: a rejected version is resubmitted through the same
card, never by creating a new version.

View saved version →

---
name: worldwide-pricing
description: >-
  Price an iOS app fairly in every App Store storefront using purchasing
  power parity, the Big Mac index, the Spotify index, or plain conversion,
  then stage the new prices for the person's own app behind a change card.
  Use for "what should my app cost in India", "PPP pricing", "make it
  affordable in Brazil", "reprice worldwide".
---

# Worldwide pricing

## The base price is the person's decision

Never choose a base price for them, and never treat the current price as the
answer. If they have not said one, ask for it (and which storefront it is set
in) before calculating.

## Any app, no account: explore

`calculate_worldwide_prices` takes `basePrice`, `baseTerritory` (default US)
and `strategy` (`ppp`, `bigmac`, `spotify`, `direct`), and returns every
storefront snapped to Apple's real price points, compared with a flat
currency conversion. Pass `focusTerritories` for the countries they asked
about so those lead the card.

## Their own app: stage it

1. `apple_list_apps`, then `apple_get_app_pricing` for the current schedule.
2. `pricing_compute_prices` with the same strategy and base price; it compares
   current against target per storefront and returns `stagedInput`.
3. Pass `stagedInput` unchanged to `apple_preview_set_territory_prices`. The
   change card shows every storefront that moves; the person presses Apply.

New prices become live on the store when applied. Mention any storefront where
the price rises, not only the discounts.