Connect AppFollow to Claude: Track App Store Rankings & Keywords

If your team needs to connect AppFollow to Claude to track App Store Optimization (ASO) rankings, analyze sentiment across thousands of user reviews, or automate keyword research, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool-calling capabilities and AppFollow's REST API. You can build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses ChatGPT, check out our sibling guide on connecting AppFollow to ChatGPT or explore our broader architectural overview on connecting AppFollow to AI Agents.

Giving a Large Language Model (LLM) read and write access to a mobile growth data platform like AppFollow is an engineering challenge. You have to map highly nested JSON schemas to MCP tool definitions, handle opaque reporting endpoints, and manage aggressive API quotas. Every time AppFollow updates an endpoint or changes a return schema, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for AppFollow, connect it natively to Claude, and execute complex app growth workflows using natural language.

The Engineering Reality of the AppFollow API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools over JSON-RPC 2.0, the reality of implementing it against specialized B2B APIs is painful. AppFollow is built to aggregate fragmented data from the Apple App Store, Google Play, and custom sources into a single pane of glass. Its API reflects the complexity of that aggregation.

If you decide to build a custom AppFollow MCP server, here are the specific integration challenges you will face:

The Credit-Based Quota System and 429 Cascades Unlike standard SaaS APIs that rate-limit based on a flat requests-per-minute threshold, AppFollow utilizes a credit-based system where specific operations cost different amounts. For example, a basic keyword ranking fetch costs 10 credits, while requesting a summary of reviews costs 10 credits plus an additional 10 credits per 30-day window analyzed.

An AI agent left unchecked will iterate through dates and quickly exhaust your workspace quota. When this happens, AppFollow returns an HTTP 429 Too Many Requests response. It is critical to note that Truto does not retry, throttle, or apply backoff on rate limit errors. When AppFollow returns a 429, Truto explicitly passes that error directly back to the caller (Claude) to ensure the LLM knows the execution failed. Truto normalizes the upstream rate limit information into standard IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller - in this case, the LLM framework - is entirely responsible for deciding whether to pause, back off, or abort the workflow. You cannot rely on the integration layer to absorb bad AI looping behavior.

The ID Bifurcation (Collections vs. Store Extensions) AppFollow requires strict relational chaining to query data. You cannot simply request "all reviews for all my apps." You must first query the Collections endpoint to retrieve an apps_id (Workspace ID). From there, you query the Apps endpoint to retrieve the ext_id (the external store ID, like an iTunes ID or Google Play package name). Almost all valuable endpoints - reviews, ASO rankings, keyword suggestions - require this ext_id. If your MCP server does not expose these discovery endpoints clearly, Claude will hallucinate IDs or fail to execute tasks.

Opaque and Dynamic Reporting Schemas Many of AppFollow's ASO report endpoints return dynamic fields arrays that are not strictly enumerated in their OpenAPI specification. The response structure changes based on whether you requested data sliced by channel, country, or report_type. Building static MCP tools for these endpoints often results in parsing errors when the LLM encounters unexpected JSON shapes. A dynamic, documentation-driven MCP server derives tools directly from live schemas, standardizing the input parameters so the LLM knows exactly which flags to pass.

Generating the AppFollow MCP Server

Truto derives MCP tools dynamically from the AppFollow integration's resource definitions and documentation records. A tool only appears in the MCP server if it has a corresponding documentation entry - acting as a quality gate to ensure Claude only sees well-documented endpoints.

Each MCP server is scoped to a single integrated AppFollow account and secured via a cryptographic token in the URL. You can generate this server via the Truto UI or programmatically via the REST API.

Method 1: Via the Truto UI

For internal operations teams or IT admins configuring Claude Desktop for their local environment, the UI is the fastest path.

1. Log into Truto and navigate to the integrated account page for your connected AppFollow instance.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can name the server, apply method filters (e.g., restrict the server to read operations only), or filter by tool tags.
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Via the Truto API

For platform engineers embedding AI agents into their own products, MCP servers can be generated programmatically on demand. This validates that the AppFollow integration has tools available, generates a secure token, and returns a ready-to-use URL.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "AppFollow ASO Agent Server",
    "config": {
      "methods": ["read", "write"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The response returns the tokenized endpoint. The token itself is hashed via HMAC before storage - the raw token string in the URL is your only authentication mechanism (unless you enforce API token auth, detailed in the security section).

{
  "id": "mcp_8f92a1",
  "name": "AppFollow ASO Agent Server",
  "config": { "methods": ["read", "write"] },
  "expires_at": "2026-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}

Connecting the MCP Server to Claude

Once you have the Truto MCP URL, you need to configure Claude to use it as a custom tool connector. Truto handles the entire JSON-RPC 2.0 handshake (initialize, tools/list, tools/call); the client just needs to point to the URL.

Method A: Via the Claude UI (Enterprise / Team)

If you are using Claude's web interface on an Enterprise or Team plan:

1. Navigate to Settings -> Integrations.
2. Click Add MCP Server or Add custom connector.
3. Paste your Truto MCP URL into the Server URL field.
4. Save the configuration. Claude will immediately send a tools/list request and populate the agent's context with the available AppFollow tools.

Method B: Via Claude Desktop Configuration

If you are building locally or deploying custom agents via Claude Desktop, you must configure the claude_desktop_config.json file. Because Truto's MCP servers communicate over HTTP POST via Server-Sent Events (SSE), you use the official @modelcontextprotocol/server-sse package as the command wrapper.

Open your configuration file (typically located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows) and add the following:

{
  "mcpServers": {
    "appfollow": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f67890"
      ]
    }
  }
}

Restart Claude Desktop. A plug icon will appear in the input bar indicating that the AppFollow tools are registered and ready for execution.

AppFollow Hero Tools for Claude

Truto automatically translates AppFollow's endpoints into descriptive, snake_case tools. Below are the highest-leverage tools available to Claude for app growth and support operations.

list_all_app_follow_collections

This is the foundational discovery tool. Before Claude can query reviews or keywords, it needs to know which workspaces exist. This tool returns the apps_id required by downstream tools.

"List all the app collections in my AppFollow account and tell me the default country and ID for each workspace."

list_all_app_follow_apps

Once Claude has an apps_id, it uses this tool to list the specific apps being tracked within that collection. This is where Claude retrieves the ext_id (e.g., the Apple App Store ID) needed to query ASO data or reviews.

"Using the collection ID '12345', list all the apps we are currently tracking. Give me the store code and the ext_id for our main iOS application."

list_all_app_follow_reviews

Retrieves paginated user reviews for an app within a specific date range. It returns the review_id, rating, author, and content. Claude uses this tool to run sentiment analysis or find bugs reported by users.

"Fetch all the reviews for ext_id '987654321' from the last 7 days. Summarize any recurring complaints about the checkout screen."

app_follow_reviews_create_reply

Allows Claude to write data back to the App Stores via AppFollow. When an agent identifies a negative review or a resolved bug, it can use this tool to post a response to the user on behalf of the developer.

"Find the 1-star review from user 'AngryBird99' regarding the login crash. Use their review_id to post this reply: 'We are sorry about the login issue. This has been fixed in version 2.4.1.'"

list_all_app_follow_rankings

Retrieves the category rankings for a specific app across different countries and devices. Claude uses this to generate automated daily performance briefs without forcing a human to log into the AppFollow dashboard.

"Get the current category rankings for ext_id '987654321' in the US market on iOS devices. Compare it to our ranking from exactly one week ago."

list_all_app_follow_keywords

Extracts the tracked keyword positions, popularity scores, and search volume for an app. This is crucial for automated ASO audits, allowing Claude to cross-reference search popularity with current app positions.

"List all tracked keywords for our app. Filter for keywords where our position has dropped below rank 10 but the popularity score remains above 50."

For a complete list of all AppFollow tools, including bulk review uploads, semantic tag management, and search ads reporting, review the AppFollow integration page.

Workflows in Action

Once Claude has access to the AppFollow MCP server, you can chain these tools together to execute complex app operations.

Scenario 1: Automated Daily ASO Audit

Instead of manually checking App Store Connect and Google Play Console, you can instruct Claude to run a daily health check on your App Store Optimization metrics.

"Run a daily ASO audit for our iOS app. Find our app ID in the main collection, fetch our current category rankings in the US, and list any tracked keywords where our rank has dropped by more than 3 positions. Give me a strategic recommendation on which keywords we need to target in our next app metadata update."

Execution Steps:

1. Claude calls list_all_app_follow_collections to find the primary workspace ID.
2. Claude calls list_all_app_follow_apps using the workspace ID to identify the iOS app's ext_id.
3. Claude executes list_all_app_follow_rankings to pull current Top Charts data for the specified app and region.
4. Claude calls list_all_app_follow_keywords to retrieve the positional keyword data.
5. Claude analyzes the returned JSON arrays, identifies the rank drops, and synthesizes a strategic markdown report.

sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant Upstream as AppFollow API

    User->>Claude: "Run daily ASO audit..."
    Claude->>MCP: tools/call list_all_app_follow_apps (apps_id)
    MCP->>Upstream: GET /apps?apps_id=...
    Upstream-->>MCP: Returns ext_id data
    MCP-->>Claude: JSON Tool Result
    Claude->>MCP: tools/call list_all_app_follow_keywords (ext_id)
    MCP->>Upstream: GET /keywords?ext_id=...
    Upstream-->>MCP: Returns keyword ranks
    MCP-->>Claude: JSON Tool Result
    Claude-->>User: Renders ASO strategy report

Scenario 2: Intelligent Review Triage and Bug Tracking

App stores are often the first place users report critical bugs. You can use Claude to actively monitor reviews and automatically tag bugs for your engineering team.

"Check the latest reviews for our Android app. Find any 1-star or 2-star reviews that mention 'crash' or 'frozen'. Reply to the user letting them know our engineers are looking into it, and tag the review with 'OTRS-urgent_bug'."

Execution Steps:

1. Claude calls list_all_app_follow_reviews with a date filter set to the last 24 hours.
2. The LLM processes the returned array of review objects, filtering for ratings <= 2 and executing text matching for "crash" or "frozen" in the content field.
3. For each matching review, Claude calls app_follow_reviews_create_reply passing the ext_id, review_id, and the drafted apology message.
4. Claude then calls app_follow_reviews_update_bug_trackers using the same IDs to apply the OTRS-urgent_bug tag, syncing the issue back to the developer's internal bug tracking system.

flowchart TD
    A["Claude fetches reviews<br>(list_all_app_follow_reviews)"] --> B{"Does review<br>mention crash?"}
    B -- Yes --> C["Create public reply<br>(app_follow_reviews_create_reply)"]
    C --> D["Tag review for Engineering<br>(app_follow_reviews_update_bug_trackers)"]
    B -- No --> E["Skip review"]

Security and Access Control

Exposing an app's public face (reviews) and marketing strategy (keywords) to an AI agent requires strict governance. Truto's MCP implementation provides multiple layers of security at the token level to ensure LLMs behave safely.

• Method Filtering: When generating the MCP server, you can restrict the configuration to methods: ["read"]. This ensures tools like app_follow_reviews_create_reply are entirely hidden from the LLM, making the integration strictly read-only.
• Tag Filtering: You can restrict the server to specific resource tags. If you only want the agent to analyze keywords but not touch reviews, you can configure the MCP token to only expose tools tagged with ["aso"].
• Temporal Expiration: By passing an expires_at ISO datetime when creating the MCP server, you can generate temporary access for an agent. Once the timestamp passes, the token is automatically revoked from edge storage.
• Double Authentication: By setting require_api_token_auth: true in the MCP config, the base URL token is no longer sufficient. The connecting client must also pass a valid Truto API token in the Authorization header. This prevents unauthorized execution even if the MCP URL is leaked in internal logs.

Wrapping Up

Building a custom AppFollow integration layer for AI agents forces your engineering team to take ownership of opaque ASO report schemas, complex ID resolution chains, and aggressive API credit quotas. By using a managed MCP server, you abstract away the API execution environment.

Truto handles the JSON-RPC 2.0 translation, dynamic schema derivation from AppFollow's live documentation, and secure edge authentication. Your AI agents get immediate, structured access to App Store rankings, keyword performance, and user sentiment, allowing you to automate growth operations without writing point-to-point integration code.