TL;DR I wrote a .NET library, CLI tool, and MCP server for fetching app reviews from App Store Connect (with Google Play support in the works). You can use them yourself with the NuGet packages AppReviewFetch, AppReviewFetch.Cli, and AppReviewFetch.Mcp. The MCP server is especially exciting because it lets AI assistants analyze your reviews for you.

If you’re an Apple app developer, you’ve done The Dance. You know the one. Open Safari. Navigate to App Store Connect. Click through seventeen dropdown menus. Wait for the world’s slowest web app to load. Click “My Apps.” Wait again. Click your app. Wait. Click “Ratings and Reviews.” Wait. Squint at a paginated table that shows you 10 reviews at a time. Wonder what your users are actually thinking. Give up and go make coffee.

This is 2026. I have apps that have been on the App Store for well over a decade. I have accumulated a lot of reviews. I want to read those reviews. I want to search those reviews. I want to understand what my users love and what makes them cry. And I don’t want to do any of that through a web browser that feels like it’s running on a Pentium II.

So I built AppReviewFetch.

The Boring Part (The Library)

At its core, AppReviewFetch is a .NET library for talking to the App Store Connect API. It handles the JWT authentication dance (which, let me tell you, is a dance), fetches your apps, fetches your reviews, handles pagination, and gives you nice strongly-typed objects to work with.

dotnet add package AppReviewFetch

using AppReviewFetch;

var service = new AppStoreConnectService();
var reviews = await service.GetReviewsAsync("YOUR_APP_ID", new ReviewRequest
{
    SortOrder = ReviewSortOrder.NewestFirst,
    Limit = 100,
    Country = "US"
});

foreach (var review in reviews.Reviews)
{
    Console.WriteLine($"{review.Rating}/5 - {review.Title}");
    Console.WriteLine(review.Body);
}

Is this exciting? Not particularly. It’s plumbing, good plumbing, I like to think. Clean interfaces, proper exception handling, support for dependency injection are all good plumbing. It’s the kind of code that has to exist so that more interesting things can be built on top of it.

If you want an easy API to build your own tools, this is it.

But I know you didn’t come here for plumbing.

The Actually Useful Part (The CLI)

Here’s my pitch: what if you never had to open App Store Connect in a web browser again to check your reviews?

dotnet tool install -g AppReviewFetch.Cli
arfetch

That’s it. Now you have a beautiful, interactive REPL that does everything the web interface does, except faster and without making you want to throw your computer out the window.

arfetch> list
┌────────────────────────────────────────────────────────────────────────────┐
│                              Available Apps                                 │
├──────────────┬─────────────────────────┬─────────────────────────┬─────────┤
│     App ID   │          Name           │        Bundle ID        │  Store  │
├──────────────┼─────────────────────────┼─────────────────────────┼─────────┤
│  123456789   │        iCircuit         │ com.krueger.icircuit    │  Apple  │
│  987654321   │          Calca          │ com.krueger.calca       │  Apple  │
└──────────────┴─────────────────────────┴─────────────────────────┴─────────┘

arfetch> fetch iCircuit
⭐⭐⭐⭐⭐ "Best circuit simulator ever!"
"I've been using this app for years and it just keeps getting better..."

⭐⭐⭐⭐☆ "Great app, one suggestion"
"Love the Arduino support! Would be nice if it could also simulate..."

arfetch> fetch iCircuit US
[Shows only reviews from the United States]

arfetch> export reviews.csv
✓ Exported 342 reviews to reviews.csv

You can search by app name, bundle ID, or app ID. You can filter by country. You can export to CSV for further analysis. The reviews are beautifully formatted with colors and star ratings. Developer responses are included. Pagination is handled with a simple “more” prompt.

It’s the kind of tool I always wished existed. So I built it.

Setup takes about two minutes: you need an App Store Connect API key (which Apple now makes reasonably easy to generate), and you run arfetch setup which walks you through entering your credentials. Done.

The Wild Part (The MCP Server)

Okay. Here’s where things get fun.

Model Context Protocol is a standardized way for AI assistants to access external data sources. GitHub Copilot supports it. Claude supports it. And now AppReviewFetch supports it.

dotnet tool install -g AppReviewFetch.Mcp

Add a few lines to your VS Code settings or Claude Desktop config, and suddenly your AI assistant can read your app reviews.

This is where things get really interesting.

You can ask GitHub Copilot, “What are users complaining about in my app?” and it will actually go fetch your reviews, analyze them, and tell you. Not hallucinated reviews from its training data. Your actual reviews. Right now. In real time.

Things You Can Do That Sound Made Up But Aren’t

“Analyze the sentiment of my reviews over the past month and tell me if things are getting better or worse.”

The MCP server will fetch hundreds of reviews, compute rating distributions, analyze trends, and give you a comprehensive report. No clicking through web pages. No exporting CSVs and opening them in Excel. Just ask.

“Show me all the 1-star reviews and categorize them by complaint type.”

Your AI assistant will identify patterns you might have missed. “42% of negative reviews mention performance issues on older devices. 28% mention difficulty with the tutorial. 17% are people who clearly don’t understand what the app does.”

“Draft responses to this week’s negative reviews.”

AI assistants are pretty good at writing polite, helpful customer service responses. Now they can do it with full context of what the user actually said.

“Compare my review sentiment to what users are saying on Reddit about my app.”

Combine the MCP server with web search and you’ve got a comprehensive view of user sentiment across platforms.

“Every morning, give me a summary of new reviews across all my apps.”

Set up a simple automation and never be surprised by a sudden influx of negative reviews again.

“Find reviews that mention crashes and correlate them with my crash reports.”

Cross-reference user-reported issues with your crash analytics to prioritize bug fixes.

The Really Wild Ideas

Here’s where my imagination starts running ahead of my implementation:

  • Automated Triage: Have an AI assistant monitor reviews and file GitHub issues for reported bugs, tagged by severity based on the language used.
  • A/B Testing Insights: After a release, ask “Are users responding better to the new design?” and get an answer based on actual review text analysis.
  • Competitive Analysis: If you’re analyzing reviews for your own apps, what about… other apps? (The API only gives you access to your own apps, but the architecture is there for when that changes.)
  • Multi-Language Sentiment: Reviews come in many languages. AI is pretty good at understanding all of them. “What are my Japanese users saying that’s different from my American users?”
  • Proactive Outreach: Identify users who left thoughtful negative reviews and might be good beta testers for new features.

I’ve built the foundation. The MCP server exposes three tools—ListApps, FetchReviews, and AnalyzeReviews—and the AI takes it from there. The creativity is limited only by what you ask it to do.

The Setup

Getting started is straightforward:

  1. Get an App Store Connect API Key
    • Go to App Store Connect → Users and Access → Keys
    • Generate a key with App Manager, Customer Support, or Admin access
    • Download the .p8 file and note your Key ID and Issuer ID
  2. Install and Configure 
    dotnet tool install -g AppReviewFetch.Cli
arfetch setup
  3. For MCP: Add the server to your AI assistant’s config: 
    {
  "servers": {
    "appreviewfetch": {
      "command": "arfetch-mcp"
    }
  }
}

That’s it. The CLI and MCP server share the same credentials file, so configure once, use everywhere.

The Three Packages

  • AppReviewFetch - The core library. Use this if you’re building your own tooling.
  • AppReviewFetch.Cli - The interactive CLI. Use this if you want a better alternative to App Store Connect’s web interface.
  • AppReviewFetch.Mcp - The MCP server. Use this if you want AI to do the analysis for you.

All three are MIT licensed and available on GitHub.

What’s Next

Google Play support is in early beta. The API is different (shocker), and Google’s authentication is its own special adventure, but the architecture is already there—the library is built around an IAppReviewService interface that can support multiple stores.

I also want to add Windows Store support, but I haven’t looked into that API yet.

There are of course other sources of feedback for apps, email and social media being the big ones. If I can find reliable APIs for those, I may add them as well.

The Real Point

I’ve been an iOS developer since 2008. Eighteen years. That’s a lot of reviews. That’s a lot of time spent in App Store Connect’s web interface, clicking and waiting and clicking and waiting.

Developer tools should respect developers’ time. They should be fast. They should be automatable. They should integrate with the workflows we’re already using.

App Store Connect is none of those things. So I built something that is.

And now that AI assistants can actually understand and act on data from external sources, the potential for what we can do with our apps’ feedback has exploded. The reviews are just sitting there. They’re full of insights. We just need better ways to access them.

AppReviewFetch on GitHub NuGet Packages