How to Export App Store Reviews to CSV

Exporting App Store reviews to CSV turns scattered public feedback into a dataset you can filter, share, and analyze. A review export can help a product team find release regressions, compare recurring complaints, collect feature requests, or examine how customer sentiment changes across app versions.

There are three practical ways to create the export with FetchLayer:

1. Use FetchLayer Research Chat to retrieve and analyze the reviews in plain English, then download a CSV or JSON file.
2. Use the App Store Reviews API to fetch structured JSON and generate a CSV inside your own workflow.
3. Connect FetchLayer MCP to Claude, Codex, Hermes, or another compatible AI client and ask your own agent to retrieve, analyze, and export the reviews.

The chat route is faster for one-off research. The API route is better for recurring exports, monitoring jobs, internal tools, and custom data pipelines.

Want the underlying review endpoint? See the App Store Reviews API. For a broader collection tutorial, read how to scrape App Store reviews.

For JavaScript and TypeScript developers, the official @fetchlayer/appstore npm package wraps the endpoints with typed responses. It is open source on GitHub.

What should an App Store review CSV contain?

A useful export should preserve the original review and enough context to explain it later. Recommended columns include:

For AI analysis, you can add derived columns such as theme, sentiment, issue_type, urgency, and summary. Keep those classifications beside the original text rather than replacing it. That makes every conclusion easier to verify.

Method 1: Export App Store reviews with AI and no code

FetchLayer Research Chat combines review retrieval, analysis, and file creation in one workflow. You describe the app and the result you want; the chat can find the app, fetch its public reviews, classify the feedback, and prepare a downloadable artifact.

Start with a specific prompt:

Analyze the recent App Store reviews for this app. Group recurring bugs, feature requests, and praise by theme. Export a CSV with the rating, review text, app version, date, theme, and sentiment.

If the app is ambiguous, include its App Store URL or numeric app ID. You can also specify a country, language, sort order, or review-page limit.

After the first result, refine the same file with follow-up instructions:

• Keep only one-star and two-star reviews.
• Add an urgency score from 1 to 5.
• Separate login problems from syncing problems.
• Show which issues started in the latest version.
• Rank themes by review count.
• Convert the current file from JSON to CSV.

The chat keeps the structured data in an artifact rather than only returning a prose summary. You can inspect it in the browser and download it when the columns and classifications are ready.

Open App Store review analysis in Research Chat

Method 2: Fetch reviews through the API

Use the API when you need predictable automation or want to control the CSV generation yourself.

First, request the public reviews:

curl -X POST https://api.fetchlayer.dev/appstore/reviews \
  -H "Authorization: Bearer ss-your-key" \
  -H "Content-Type: application/json" \
  -d '{
    "appId": "1234567890",
    "country": "us",
    "pages": 2,
    "reviewsPerPage": 20,
    "sort": "recent"
  }'

The endpoint returns structured review records, so the conversion step does not need to parse App Store HTML.

Convert the JSON response to CSV in JavaScript

The example below requests reviews and creates CSV text with a fixed set of columns:

const response = await fetch('https://api.fetchlayer.dev/appstore/reviews', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.FETCHLAYER_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    appId: '1234567890',
    country: 'us',
    pages: 2,
    reviewsPerPage: 20,
    sort: 'recent',
  }),
});

if (!response.ok) throw new Error(`FetchLayer returned ${response.status}`);

const { reviews } = await response.json();
const columns = ['id', 'rating', 'title', 'body', 'author', 'version', 'date', 'helpfulCount'];

const escapeCsv = (value) => {
  const text = String(value ?? '');
  return `"${text.replaceAll('"', '""')}"`;
};

const csv = [
  columns.join(','),
  ...reviews.map((review) => columns.map((column) => escapeCsv(review[column])).join(',')),
].join('\n');

await Bun.write('app-store-reviews.csv', csv);

Use a CSV library when your workflow needs streaming, very large exports, custom delimiters, or advanced type handling. The important part is to define the schema explicitly instead of depending on whatever object-key order happens to arrive.

Open the CSV in Excel or Google Sheets

A standard UTF-8 CSV opens in spreadsheet tools such as Excel, Google Sheets, Numbers, and LibreOffice. Review text can contain commas, quotation marks, and line breaks, so every text value should be escaped correctly.

For spreadsheet analysis, useful filters include:

• Rating equal to 1 or 2
• App version equal to the latest release
• Review date after a release date
• Theme equal to bugs, billing, performance, or feature requests
• Helpful count above a chosen threshold

Pivot tables can then compare theme frequency by rating or app version. This is often more informative than a single average sentiment score.

Build a recurring review export

For monitoring, run the API request on a schedule and store the review ID from every row. On the next run, export only IDs you have not seen before.

Scheduled job → Fetch recent reviews → Remove known IDs → Classify new feedback → Update CSV or database

Keep the raw reviews in a durable store even if the team mainly works from a spreadsheet. CSV is convenient for handoff; a database is usually safer as the long-term source of truth.

See the complete App Store review monitoring workflow for deduplication and alerting ideas.

Method 3: Use your own AI agent through MCP

Research Chat is the fastest no-code route, but it does not have to be the AI interface you use. Connect FetchLayer to Claude, Codex, Hermes, or another MCP-compatible client, then ask the agent to retrieve the reviews and create the exact CSV schema you need.

For example:

Retrieve recent App Store reviews for this app. Group recurring bugs by app version, separate feature requests from pricing objections, retain the original review text and IDs as evidence, then export the result as CSV.

The agent works from FetchLayer’s source data, so you keep the retrieval, analysis, and file creation in one workflow. Connect your MCP client to FetchLayer.

Exporting competitor App Store reviews

Public review retrieval is useful for competitor research because it does not require access to the app owner’s App Store Connect account. You can compare repeated complaints, requested features, regional feedback, or reaction to a recent update.

Use the same columns for every app and add app_id and app_name. Consistent schemas make it possible to compare theme frequency across products without merging incompatible spreadsheets later.

Avoid treating a CSV export as a representative survey of every customer. Public reviewers are self-selecting, storefront availability varies, and visible reviews are one source of evidence rather than a complete view of the market.

Next steps

• Analyze App Store reviews with AI
• Explore the App Store Reviews API
• Monitor new App Store reviews
• Create a free FetchLayer account