DEV Community: frankxie

How to Export Public Telegram Channel Posts to CSV (Text, Views, Dates, Links) Without an Account or API Key

frankxie — Tue, 03 Nov 2026 13:31:05 +0000

A lot of public information appears on Telegram first. Exchanges post listings and delistings there, projects announce releases, and news channels push stories before the website updates. If you research a market or monitor a competitor, you will eventually want those posts in a table: one row per post, with the text, date, view count and links.

The official routes are awkward. The Bot API only sees channels where your bot is an admin. The full MTProto API (Telethon, Pyrogram) works, but needs a Telegram account with a phone number, an api_id from my.telegram.org and a session file to keep safe. That is a lot of setup for posts anyone can already read at t.me/s/<channel> in a browser.

This tutorial uses an Apify Actor that reads that public web preview and exports the posts as JSON, CSV or Excel.

Disclosure: I built and maintain this Actor. It is a paid tool ($1.00 per 1,000 results). The limitations section at the end is as important as the rest.

What you can do with the data

Monitor announcement channels. Pull 30 days of an exchange's channel and tag each post: delisting, new listing, maintenance, promotion.
Compare channels. Views per post, posting frequency and hours, and which sites they link to.
Build a research dataset. Original-language text with dates and engagement, ready for topic or sentiment analysis.

Step 1: Set up a run in Apify Console

Open Telegram Channel Scraper and click Try for free. The input form has these fields:

Field	What it does
What to scrape (`mode`)	`posts` (posts of channels), `search` (posts that contain a keyword) or `channelInfo` (one row per channel, with subscriber count and description).
Channels (`channels`)	Public channels as names (`durov`), @names (`@durov`) or links (`https://t.me/durov`).
Search keyword (`searchQuery`)	Only for search mode.
Max results (`maxItems`)	Upper limit for the whole run. You're only charged for saved results.
Max posts per channel (`maxItemsPerChannel`)	Stops one busy channel from using up the whole run.
Only posts newer than (`postedAfter`)	A date like `2026-10-01` or a period like `7 days`. The Actor stops reading a channel when it reaches older posts.
Single post links (`postUrls`)	Optional links like `https://t.me/telegram/105` if you only need specific posts.

No Telegram account, phone number, API key or proxy is needed.

Step 2: Run it and export

Click Start. When the run finishes, open the Output tab and export as JSON, CSV or Excel.

For this article I ran this input, the newest 10 posts each from Binance's announcement channel and Telegram's own news channel:

{
  "mode": "posts",
  "channels": ["binance_announcements", "telegram"],
  "maxItemsPerChannel": 10,
  "maxItems": 20
}

It finished in about 4 seconds and saved 20 posts. Here are two of them. I removed the textHtml field, the media list (long file links) and most empty fields to keep this short; the values that remain are unchanged. Both are public brand channels, and none of these posts had an author signature, so there was nothing personal to redact:

[
  {
    "type": "post",
    "channel": "binance_announcements",
    "channelTitle": "Binance Announcements",
    "messageId": 9089,
    "url": "https://t.me/binance_announcements/9089",
    "text": "Notice of Removal of Spot Trading Pairs - 2026-10-30\n\n\nBased on our most recent reviews, Binance will remove and cease trading on the following spot trading pairs:\n- At 2026-10-30 03:00 (UTC): AAVE/BTC, ATOM/BTC, CAKE/BTC, DASH/BTC, ETC/BTC, ICP/BTC, PENDLE/BTC, RENDER/BTC, TAO/BTC, THETA/BTC, XAUT/BTC and XTZ/BTC\n\n👉🏻 Learn more here",
    "postedAt": "2026-10-27T08:31:38Z",
    "views": 20700,
    "isEdited": false,
    "mediaTypes": ["photo"],
    "mediaCount": 1,
    "links": ["https://www.binance.com/en/support/announcement/detail/de45689cbd7b4e1fa87055cdf5a85997?utm_source=EnglishTelegram&utm_medium=GlobalCommunity&utm_campaign=AnnouncementBot"],
    "hashtags": [],
    "mentions": [],
    "reactionsTotal": 93,
    "reactions": [
      {"emoji": "❤", "count": 35, "isPaid": false, "customEmojiId": null},
      {"emoji": "🤔", "count": 26, "isPaid": false, "customEmojiId": null},
      {"emoji": "👍", "count": 16, "isPaid": false, "customEmojiId": null},
      {"emoji": "🤯", "count": 8, "isPaid": false, "customEmojiId": null},
      {"emoji": "👏", "count": 5, "isPaid": false, "customEmojiId": null},
      {"emoji": "🙏", "count": 3, "isPaid": false, "customEmojiId": null}
    ],
    "scrapedAt": "2026-10-27T21:24:28Z"
  },
  {
    "type": "post",
    "channel": "telegram",
    "channelTitle": "Telegram News",
    "messageId": 453,
    "url": "https://t.me/telegram/453",
    "text": "350 Million GIFs. The GIF panel now contains over 350 million GIFs in 36 languages.\n\nYour Telegram GIF searches are entirely private and do not rely on any third parties.\n\nJuly Features\n1 • 2 • 3 • 4 • More",
    "postedAt": "2026-07-19T17:58:17Z",
    "views": 2020000,
    "isEdited": false,
    "mediaTypes": ["video"],
    "mediaCount": 1,
    "links": ["https://t.me/telegram/450", "https://t.me/telegram/451", "https://t.me/telegram/452", "https://t.me/telegram/454"],
    "hashtags": [],
    "mentions": [],
    "reactionsTotal": null,
    "reactions": [],
    "scrapedAt": "2026-10-27T21:24:28Z"
  }
]

Even 20 rows show a few patterns. The 10 Binance posts covered five days, and all of them went out within two minutes after the hour or half hour (07:02, 08:01, 08:31, 09:01 UTC and so on), which looks scheduled. The 10 Telegram posts came from two feature drops, in July and August, each posted as a burst of messages within a minute or two. Telegram's channel shows no reactions, so reactionsTotal is null there, not zero.

links holds every link in the post, including ones hidden behind text like "Learn more here".

Step 3: Do it from Python

Install the official client and pandas:

pip install apify-client pandas

Then pull the last 30 days of one channel and save a flat CSV:

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("pipiagent/telegram-channel-scraper").call(run_input={
    "mode": "posts",
    "channels": ["binance_announcements"],
    "postedAfter": "30 days",
    "maxItems": 2000,
})

items = list(client.dataset(run.default_dataset_id).iterate_items())
df = pd.DataFrame(items)

# Flat columns for the CSV; nested lists like media and reactions are easier to use from JSON.
cols = ["channel", "messageId", "postedAt", "views", "reactionsTotal", "text", "url"]
df[cols].to_csv("binance_announcements_30d.csv", index=False)

Now tag and summarise the posts. Some posts have no text or no reactions, so the code handles missing values:

df["postedAt"] = pd.to_datetime(df["postedAt"], utc=True)
text = df["text"].fillna("").str.lower()

categories = {
    "delisting": r"removal|delist|will remove",
    "new listing": r"will list|new trading pairs|will support",
    "maintenance": r"maintenance|upgrade",
    "promotion": r"competition|campaign|rewards?|giveaway",
}
df["category"] = "other"
for name, pattern in categories.items():
    df.loc[df["category"].eq("other") & text.str.contains(pattern), "category"] = name

summary = df.groupby("category").agg(
    posts=("messageId", "count"),
    median_views=("views", "median"),
    median_reactions=("reactionsTotal", "median"),
).sort_values("posts", ascending=False)
print(summary)

# Posting hours (UTC)
print(df["postedAt"].dt.hour.value_counts().sort_index())

# Which sites the channel links to
domains = df["links"].explode().dropna().str.extract(r"https?://([^/?]+)")[0]
print(domains.value_counts().head(10))

The patterns are a starting point for this one channel; adjust them after reading a few dozen posts.

To monitor a channel, schedule the same input in Apify with "postedAfter": "1 day" and append each run's results to your table. De-duplicate on channel + messageId, because runs can overlap.

What it costs

You pay per saved result: $1.00 per 1,000 results, with no start fee and no monthly rental. A post with an album of ten photos is still one result.

The 20-post test above: $0.02
30 days of a channel that posts about 10 times a day (around 300 posts): about $0.30
Channel info (subscriber count, description) for 50 channels: $0.05

You can set a maximum charge per run in the run options, and the Actor stops when it reaches it.

Limitations

These mostly come from what Telegram shows on its public web preview:

Public channels only. Private channels, invite links (t.me/+...), groups, bots and user accounts can't be read. They are skipped with a warning in the log.
Some public channels have no web preview. Owners can turn it off, Telegram hides some restricted channels, and a channel blocked in the country of Apify's servers looks like it doesn't exist (a proxy can help).
No comments. Comments under posts aren't part of the web preview.
Views and reactions are rounded by Telegram above 1,000 ("20.7K" becomes 20700), so small differences between posts don't mean much.
Views keep growing after a post goes out. In my sample, Binance posts from four days earlier had more than twice the views of the newest ones. Compare posts of similar age, or re-run later.
Some post types show no content on the web. Live streams, giveaways and paid media come back with empty text and a mediaNote.
Media links expire. The Actor saves links to photos and videos, not the files. Download them soon if you need them.
Search returns at most about 22 posts per channel and keyword. For more, scrape the channel's posts and filter them yourself, as in the example above.
Old posts take time. The Actor reads newest to oldest at roughly 1,000 posts a minute.
Personal data. Author signatures and forwarded-from names can identify people. If you store them, make sure you have a legitimate reason under GDPR or similar laws.

If you track many channels, run channelInfo mode daily to build a subscriber history.

The store page has more input examples. If something doesn't match what this article says, open an issue there and I'll look into it.

How to Collect YouTube Shorts Data for a Niche (Views, Likes, Publish Dates) Without the API Quota

frankxie — Mon, 02 Nov 2026 13:21:07 +0000

If you make Shorts, run social for a brand, or analyse short-form video, you will eventually want a table like this one: every Short in a niche, with its views, likes, comments, length, publish date and channel. Then you can see which formats actually work, which channels keep breaking out, and how fast things move.

Getting that table from the official YouTube Data API is harder than it sounds. The default quota is 10,000 units per day, and every search.list call costs 100 of them, so you get roughly 100 searches a day before you count the follow-up videos.list calls you need for statistics. The API also has no Shorts-only search filter. The closest thing is videoDuration=short, which means "under four minutes", so regular videos come back too.

This tutorial shows another route: an Apify Actor that searches Shorts the way the YouTube app does and exports the results as JSON, CSV or Excel.

Disclosure: I built and maintain this Actor. It is a paid tool ($1.00 per 1,000 results). I've tried to describe what it can't do as plainly as what it can.

What you can do with the data

Find the formats that work in a niche. Pull a few hundred Shorts for "meal prep" or "budget travel", then sort by views and read the top 30 titles. Patterns show up quickly: hooks, lengths, "for the week" vs "in 1 hour".
Track a competitor's Shorts. Give it a channel handle and you get that channel's Shorts newest first, with exact numbers. Schedule it weekly and you have a history.
Build a dataset for analysis. Engagement rate by length, median views by upload week, which hashtags show up on the top performers.

Step 1: Set up a run in Apify Console

Open YouTube Shorts Scraper and click Try for free. The input form has these fields:

Field	What it does
Search keywords (`searchQueries`)	One or more keywords, e.g. `meal prep`.
Channels (`channelUrls`)	Channel URLs or handles like `@NicksKitchen`. You get that channel's Shorts, newest first.
Max results (`maxItems`)	Upper limit for the whole run. You're only charged for saved results.
Max results per keyword or channel (`maxItemsPerQuery`)	Stops one source from using up the whole run.
Add full details (`shortsDetails`)	On by default. Opens each Short to add exact views, likes, comment count, publish date, channel, description and hashtags.
Sort by (`sortBy`)	`relevance` or `date` ("Recent first"). Applies to keywords only.
Uploaded (`uploadDate`)	`any`, `hour`, `today`, `week`, `month`, `year`. Applies to keywords only.

You can use keywords, channels or both. No YouTube API key, login or proxy setup is needed.

Step 2: Run it and export

Click Start. When the run finishes, open the Output tab and export as JSON, CSV or Excel.

For this article I ran one keyword, meal prep, with maxItems: 20 and full details on. It saved 20 Shorts in about 30 seconds. Here are two of them, with some fields removed to keep this short (values unchanged):

[
  {
    "videoId": "s8wAVav48NE",
    "url": "https://www.youtube.com/shorts/s8wAVav48NE",
    "title": "🍗 Meal Prep on a Budget! 💰",
    "viewCount": 14544,
    "likeCount": 937,
    "commentCount": 17,
    "durationSeconds": 91,
    "publishedAt": "2026-10-27T15:27:52Z",
    "hashtags": ["#SummersHomemadeMeals", "#MealPrepIdeas", "#HealthyOnABudget"],
    "channelName": "Summers_homemade_meals",
    "channelHandle": "@summers_homemade_meals",
    "channelSubscriberCount": 536000,
    "searchQuery": "meal prep",
    "scrapedAt": "2026-10-27T21:20:56Z"
  },
  {
    "videoId": "TRlli6WOsFA",
    "url": "https://www.youtube.com/shorts/TRlli6WOsFA",
    "title": "How I Meal Prep for the Whole Week (in just 1 hour) 👨🏻‍🍳🍲",
    "viewCount": 735662,
    "likeCount": 15548,
    "commentCount": 282,
    "durationSeconds": 137,
    "publishedAt": "2026-08-27T16:20:09Z",
    "hashtags": ["#mealprepping", "#whatieatinaday", "#whatieat"],
    "channelName": "Zack Venios",
    "channelHandle": "@ZackVenios",
    "channelSubscriberCount": 6390,
    "searchQuery": "meal prep",
    "scrapedAt": "2026-10-27T21:20:56Z"
  }
]

Even in this tiny sample, the second Short has about 735K views from a channel with about 6K subscribers. That's the kind of thing you want to spot across a few hundred rows.

A few notes on the fields. hashtags holds the hashtags YouTube shows above the title, which is usually up to three. The full text is in description. Every row also has a searchQuery field that tells you which keyword found it.

Step 3: Do it from Python

Install the official client and pandas:

pip install apify-client pandas

Then run the Actor and load the results:

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "searchQueries": ["meal prep", "meal prep for the week", "high protein meal prep"],
    "maxItemsPerQuery": 120,
    "maxItems": 400,
    "shortsDetails": True,
    "sortBy": "relevance",
    "uploadDate": "any",
}

run = client.actor("pipiagent/youtube-shorts-scraper").call(run_input=run_input)
items = list(client.dataset(run.default_dataset_id).iterate_items())

df = pd.DataFrame(items)
# The same Short can be found by several keywords; keep one copy for analysis.
df = df.drop_duplicates(subset="videoId")
df["publishedAt"] = pd.to_datetime(df["publishedAt"])
df["likeRate"] = df["likeCount"] / df["viewCount"]

# Top 10 Shorts by views
print(df.nlargest(10, "viewCount")[["title", "channelHandle", "viewCount", "durationSeconds"]])

# Median views by upload week (useful when you search with uploadDate="month")
weekly = df.set_index("publishedAt").resample("W")["viewCount"].median()
print(weekly.tail(8))

To track a competitor, swap the keywords for "channelUrls": ["@SomeChannel"] and set maxItemsPerQuery to however many recent Shorts you care about.

What it costs

You pay per saved result: $1.00 per 1,000 Shorts, with no start fee and no monthly rental. Turning on full details doesn't change the price.

A 20-Short run like my test: $0.02.
Three keywords at about 120 Shorts each (around 360 rows): about $0.36.
500 Shorts from one channel: $0.50.

You can also set a maximum charge per run in the run options, and the Actor stops when it reaches that amount.

Limitations

These come from how YouTube serves Shorts, so it's better to know them before you plan a project:

About 100–140 Shorts per keyword. YouTube's Shorts search stops there. Changing the sort order or upload date adds only a few more. To get a bigger sample, use several related keywords, as in the Python example.
No sort by views. YouTube returns nothing for Shorts sorted by views, so the Actor offers relevance and date only. Sort the exported table by viewCount instead.
Upload date filters shrink results a lot. With "This week", a keyword often returns only a dozen or so Shorts, and occasionally none.
Full details are slower. The Actor opens every Short. 100 Shorts take about 2 minutes, compared with about 10 seconds with details off. With details off, you only get the title and a rounded view count (e.g. "40M"), without likes, dates or the channel.
Channel Shorts come newest first. YouTube doesn't offer another order.
Duplicates across keywords are kept, so de-duplicate on videoId as shown above.

Related tools

If you need regular long-form videos rather than Shorts, YouTube Search Scraper handles keyword search with upload-date filters and sort by views. YouTube Channel Videos Scraper exports every upload of a channel and can include Shorts and live streams.

If you want to try the Shorts workflow on your own niche, the YouTube Shorts Scraper store page has the input form and more examples. If something doesn't work the way this article says, open an issue there and I'll look into it.

How to Compare Alibaba Wholesale Prices and MOQs Across Hundreds of Suppliers in a Spreadsheet

frankxie — Fri, 30 Oct 2026 12:07:33 +0000

If you have ever sourced a product on Alibaba.com, you know how it goes. You search "silicone phone case", open a listing, note the price range and the minimum order quantity (MOQ), check whether the supplier is Verified and offers Trade Assurance, go back, and do it again. After 30 tabs you have a messy spreadsheet and you have seen maybe 2% of the suppliers.

This tutorial shows a faster route. You pull the search results into a table with an Apify Actor, then filter and sort them in Excel or pandas: lowest unit price at MOQ, MOQ under 100, Verified suppliers only, price at 1,000 units, and so on.

Disclosure: I built and maintain this Actor. It is a paid tool ($1.50 per 1,000 results). Everything below is based on a real test run, and the limitations section is at the end.

What you get per product

Each search result is one row. The fields that matter for sourcing:

priceMin, priceMax, priceText: the price range the supplier lists, in USD
minOrderQuantity, minOrderUnit: the MOQ, for example 10 and pieces
priceTiers: the quantity price breaks, e.g. 10–190 pcs at $0.68, 200–990 at $0.62
verifiedSupplier, verifiedSupplierPro, tradeAssurance, goldSupplier: the badges
supplierCountryCode, supplierYearsOnAlibaba, supplierRating, supplierResponseRate, supplierOrders6Months
keyword, position: which search found it and where it ranked

There is also a Product details mode. You give it product URLs or IDs and get attributes, variants, lead times per quantity, and package size and weight. It runs at about 40 products per minute, so the usual workflow is to search wide first and then fetch details only for your shortlist.

Step 1: Configure the run in Apify Console

Open the Alibaba Search Scraper store page and click Try for free. Then fill in:

What to scrape: Search results (keywords).
Search keywords: one per line, e.g. silicone phone case, liquid silicone case. You can also paste an Alibaba.com search URL.
Max results per keyword and Max results in total: these limit how much you pay.
Filters (optional, these are the same filters as on the website):
- Verified suppliers only / Verified Pro suppliers only
- Supplier country (China, Vietnam, India, Turkey, US and others)
- Minimum / Maximum price (USD): whole dollars only
- Max minimum order: e.g. 100 keeps products you can order in quantities of 100 or fewer
Include price tiers: leave this on if you want the quantity price breaks.

Click Start. When the run finishes, open the dataset and export it as CSV, Excel or JSON. In CSV and Excel, the nested priceTiers list is flattened into columns such as priceTiers/0/price, which is fine for a quick look. For tier math, JSON plus pandas is easier.

Step 2: Look at the data

I ran one keyword, silicone phone case, with 20 results. The run took about 5 seconds. Here is one record. I removed some fields to keep it short, but the values are unchanged:

{
  "productId": "1601560752583",
  "title": "JOYPORODO S002 Wholesale Silicone Mobile Cover Cell Phone Case For IPhone 17 16 15 Pro Max Coque Telephone Capa De Celular",
  "url": "https://www.alibaba.com/product-detail/JOYPORODO-S002-Wholesale-Silicone-Mobile-Cover_1601560752583.html",
  "priceText": "US $0.52-$0.68",
  "priceMin": 0.52,
  "priceMax": 0.68,
  "currency": "USD",
  "minOrderQuantity": 10,
  "minOrderUnit": "pieces",
  "productCertifications": ["CE", "ROHS"],
  "supplierName": "Guangzhou Songdo Bird Technology Development Co., Ltd.",
  "supplierCountryCode": "CN",
  "supplierYearsOnAlibaba": 3,
  "verifiedSupplier": true,
  "tradeAssurance": true,
  "supplierRating": 4.6,
  "supplierResponseRate": "99.8%",
  "supplierOrders6Months": 699,
  "keyword": "silicone phone case",
  "position": 2,
  "priceTiers": [
    {"minQuantity": 10, "maxQuantity": 190, "price": 0.68, "promotionPrice": null, "unit": "pieces"},
    {"minQuantity": 200, "maxQuantity": 990, "price": 0.62, "promotionPrice": null, "unit": "pieces"},
    {"minQuantity": 1000, "maxQuantity": 7990, "price": 0.57, "promotionPrice": null, "unit": "pieces"},
    {"minQuantity": 8000, "maxQuantity": null, "price": 0.52, "promotionPrice": null, "unit": "pieces"}
  ]
}

Even in 20 rows the spread is wide. MOQs went from 1 piece to 5,000 pieces, 18 of 20 had an MOQ of 100 or less, 17 were from Verified suppliers, and one listing had no price tiers at all. This spread is the reason to put the results in a table instead of reading them one by one.

Step 3: Run it from Python and rank suppliers with pandas

Install the official client and pandas:

pip install apify-client pandas

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("pipiagent/alibaba-search-scraper").call(run_input={
    "searchKeywords": ["silicone phone case", "liquid silicone case"],
    "maxResultsPerKeyword": 300,
    "verifiedSupplierOnly": True,
    "maxMinOrder": 100,
    "includePriceTiers": True,
})

items = list(client.dataset(run.default_dataset_id).iterate_items())
df = pd.DataFrame(items)

Now the useful part is the unit price at a given quantity. The function picks the tier that applies to that quantity and falls back to the top of the listed range when there are no tiers:

def unit_price(row, qty):
    tiers = [t for t in (row["priceTiers"] or []) if (t["minQuantity"] or 0) <= qty]
    if not tiers:
        return row["priceMax"]  # no tiers listed: use the top of the range
    return max(tiers, key=lambda t: t["minQuantity"] or 0)["price"]

df = df.dropna(subset=["minOrderQuantity", "priceMax"])
df["price_at_moq"] = df.apply(lambda r: unit_price(r, r["minOrderQuantity"]), axis=1)
df["price_at_1000"] = df.apply(lambda r: unit_price(r, 1000), axis=1)
df["cost_of_first_order"] = df["minOrderQuantity"] * df["price_at_moq"]

shortlist = (
    df[df["tradeAssurance"].eq(True) & (df["minOrderQuantity"] <= 100)]
    .sort_values("price_at_moq")
    [["title", "supplierName", "minOrderQuantity", "price_at_moq",
      "price_at_1000", "cost_of_first_order", "supplierRating", "url"]]
)
shortlist.to_csv("shortlist.csv", index=False)

For a rough margin check, add your own per-unit estimates for shipping, duties and platform fees. These numbers are yours to fill in; the scraper only gives you the supplier's listed price:

SHIPPING_PER_UNIT = 0.40   # your own estimate
FEES_PER_UNIT = 0.0        # duties, packaging, platform fees, etc.
SELL_PRICE = 9.99          # your planned retail price

shortlist["landed_cost"] = shortlist["price_at_1000"] + SHIPPING_PER_UNIT + FEES_PER_UNIT
shortlist["margin_pct"] = (SELL_PRICE - shortlist["landed_cost"]) / SELL_PRICE * 100

From there, copy the URLs of your top 10 or 20 into Product details mode ("mode": "productDetails", "productUrls": [...]) to get lead times, variants and package weight before you message suppliers.

What it costs

Pricing is pay per result: $1.50 per 1,000 results, with no start fee. Search results and product pages cost the same.

My 20-result test: $0.03
Two keywords × 300 results = 600 results: $0.90
100 product detail pages for a shortlist: $0.15

You can also set a maximum charge per run in the run options. The Actor stops when it reaches that amount.

Limitations

You get what a logged-out visitor sees. There are no supplier emails or phone numbers, and no prices that need a login or a quote request.
Prices are supplier-listed ranges, usually per unit and without shipping. Some product pages say "contact supplier" and have no price, so those fields are null. Treat every number as a starting point for negotiation.
Alibaba shows at most 100 pages per search, in its default "best match" order. There is no sorting option and no flag for sponsored listings. To go wider, split by keyword, country or price range.
Rare or misspelled keywords still return loosely related products, so check the titles.
Not every field appears on every listing. Missing values are null.
The site can change. If Alibaba changes its pages or starts blocking requests, runs can break until the Actor is updated. You can report problems in the Issues tab on the store page.

If you are comparing wholesale prices with retail prices, the sibling AliExpress Search Scraper returns AliExpress search results with price, discount, units sold, rating and delivery estimates, so you can see what similar products sell for at retail.

Questions or field requests are welcome in the comments or on the store page.

How to Export Google Play Reviews of Any App to CSV or JSON (No API Key)

frankxie — Wed, 28 Oct 2026 13:00:03 +0000

If you build or market an Android app, the reviews of your competitors are some of the most useful free research you can get. Users write down exactly which feature is missing, which update broke something, and which price change made them leave. The problem is getting those reviews out of the Play Store and into a spreadsheet where you can actually work with them.

This guide shows one way to do that without an API key and without writing code. There is also an optional Python section at the end.

Disclosure: I built and maintain this Actor. The tool used below is my own Google Play Reviews Scraper on Apify. I'll try to be clear about what it can and can't do.

Why the Play Console doesn't solve this

Google does give developers access to reviews, but only for apps you own. The Play Console shows reviews of your published apps, and the Google Play Developer API lets you read and reply to them, but the API only returns reviews created or edited in roughly the last week. Neither shows you anything about apps published by someone else.

So for competitor research you have three options: read the store page by hand and copy-paste, write and maintain your own scraper, or use a ready-made one.

What you can use the data for

A few concrete things people do with exported reviews:

Competitor research. Pull the newest 1,000 reviews of three competing apps and see what each one is praised and criticized for.
Finding feature requests and bugs. Filter to 1-star and 2-star reviews. These are where users describe broken flows and missing features in detail.
Tracking reaction to releases. Every review carries the app version it was written on, so you can group complaints by version and see whether a release made things better or worse.

Step by step in Apify Console

Open the Actor page and click Try for free (you need an Apify account).
In What to scrape, keep Reviews of apps.
In Apps, paste one or more Google Play links or app ids. The app id is the part after id= in the link: for https://play.google.com/store/apps/details?id=com.duolingo it is com.duolingo. Either format works.
Set Max results (total reviews for the run, default 100). If you scrape several apps, Max reviews per app stops one big app from using up the whole budget.
Choose Sort reviews by: Newest (good for monitoring), Most relevant (the order Google Play shows visitors) or Highest rating first.
Optionally set Star rating to keep only 1-star reviews, or any other single rating.
Set Language (for example en, de, pt-BR) and Country (two-letter code like us, gb, jp). Defaults are en and us.
Click Start. When the run finishes, open the Output tab and export as JSON, CSV or Excel.

No Google account, login or proxy is needed.

The JSON input for the test run I did for this article looked like this:

{
  "mode": "reviews",
  "appIds": ["https://play.google.com/store/apps/details?id=com.duolingo"],
  "sort": "newest",
  "rating": "1",
  "language": "en",
  "country": "us",
  "maxItems": 20
}

It finished in about 4 seconds and saved 20 reviews.

What the output looks like

Here are two of those 20 reviews. I only redacted the user names and avatar links:

[
  {
    "type": "review",
    "reviewId": "f3eaabac-31ec-4558-ab1d-610077774468",
    "appId": "com.duolingo",
    "appName": "Duolingo: Learn Languages",
    "userName": "(redacted)",
    "userImage": "https://play-lh.googleusercontent.com/...",
    "rating": 1,
    "text": "This app is very frustrating due to the endless screens you have to click through, even when you have a paid subscription. I really wish you could turn off all of these random screens for gems, chests, invites, progress, friend streaks, puzzles, and even more expensive subscriptions. It would be 5 stars if you could choose which features have popups instead of being forced to wade through the endless popups.",
    "thumbsUp": 233,
    "appVersion": "6.102.4",
    "postedAt": "2026-10-26T16:26:11Z",
    "developerReplyText": null,
    "developerReplyAt": null,
    "language": "en",
    "country": "us",
    "url": "https://play.google.com/store/apps/details?id=com.duolingo&reviewId=f3eaabac-31ec-4558-ab1d-610077774468",
    "scrapedAt": "2026-10-27T21:20:27Z"
  },
  {
    "type": "review",
    "reviewId": "4aa247ff-0567-49f5-a2bf-3cf62bb2dd20",
    "appId": "com.duolingo",
    "appName": "Duolingo: Learn Languages",
    "userName": "(redacted)",
    "userImage": "https://play-lh.googleusercontent.com/...",
    "rating": 1,
    "text": "You need to focus on better lessons and fixing all of these bugs! it's so bad! Instead they're pushing usless AI and tying them to higher priced subscriptions. They've lost their way and are actively making it a worse app. Removing a star because your speaking exercises don't even load anymore.",
    "thumbsUp": 0,
    "appVersion": "6.102.4",
    "postedAt": "2026-10-26T19:20:43Z",
    "developerReplyText": null,
    "developerReplyAt": null,
    "language": "en",
    "country": "us",
    "url": "https://play.google.com/store/apps/details?id=com.duolingo&reviewId=4aa247ff-0567-49f5-a2bf-3cf62bb2dd20",
    "scrapedAt": "2026-10-27T21:20:27Z"
  }
]

thumbsUp is the number of other users who marked the review as helpful, which makes it a good way to rank complaints. When the developer has answered, developerReplyText and developerReplyAt are filled in.

Doing the same from Python

If you'd rather script it, the official apify-client package works (pip install apify-client pandas). You need your Apify API token from the Console settings.

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("pipiagent/google-play-reviews-scraper").call(run_input={
    "mode": "reviews",
    "appIds": ["com.duolingo"],
    "sort": "newest",
    "rating": "1",
    "language": "en",
    "country": "us",
    "maxItems": 1000,
})

items = list(client.dataset(run.default_dataset_id).iterate_items())
df = pd.DataFrame(items)
df.to_csv("duolingo_1star.csv", index=False)

Now a quick look at what the 1-star reviews are about. This counts how many reviews mention each keyword, and how many helpful votes those reviews collected:

keywords = ["subscription", "ads", "bug", "crash", "refund", "streak", "ai"]
text = df["text"].fillna("").str.lower()

summary = pd.DataFrame({
    kw: {
        "reviews": text.str.contains(rf"\b{kw}\b").sum(),
        "helpful_votes": df.loc[text.str.contains(rf"\b{kw}\b"), "thumbsUp"].sum(),
    }
    for kw in keywords
}).T.sort_values("reviews", ascending=False)

print(summary)

To look at reaction to a release, group by version instead: df.groupby("appVersion").size(). Keep in mind that appVersion is empty for some reviews.

What it costs

The Actor is pay per result: $0.20 per 1,000 reviews, with no start fee or monthly rental. Some examples:

The 20-review test above: $0.004
1,000 newest 1-star reviews of one app: $0.20
2,000 reviews each for 5 competitor apps (10,000 reviews): $2.00

You can set a maximum charge per run in the run options, and the run stops when it reaches it.

Limitations

Some things to know before you rely on it:

One language per run. Google Play returns reviews for the language you choose. For several languages, start one run per language. The filter is Google's, not exact: in my 20-review English test, one review was written in French.
Only reviews with text. Most users leave stars without writing anything. Those ratings can't be collected, so the number of reviews is much smaller than the rating count shown on the store page.
appVersion is sometimes empty. Some reviews have no version (1 of 20 in my test), so version-based analysis covers most reviews, not all of them.
The date is the last edit. If a user edits a review after the developer replied, the reply can be older than the review.
Personal data. Results include public user names and avatars. If you store or process them, make sure you have a legitimate reason under GDPR or similar laws, or drop those columns.
Tested scale. Runs of up to 20,000 reviews were tested on Apify. Much larger runs should work but haven't been tested there.

The Actor also has two other modes, app details (rating breakdown, installs, price, version) and keyword search, which are useful for building a competitor list before you pull reviews.

If you try it and something is broken or missing, the Issues tab on the Actor page is the best place to report it.