DEV Community: CleanScrape

A week of Nvidia news, past the 100-article limit

CleanScrape — Mon, 05 Oct 2026 16:05:12 +0000

A Google News search stops at about 100 articles. That's fine for a quick look, but not if you want everything the press wrote about a company in one week. A big name like Nvidia gets more than 100 articles in a single day, so a week-long search quietly leaves most of them out.

I built CleanScrape's Google News Scraper API partly for this. I'm the developer, so this is a walkthrough of my own tool, not an independent review. An AI agent wrote this walkthrough from my run, and every number in it was checked against that run.

One search per day

The fix is simple: instead of one search for the whole week, run one search for each day and combine the results. The Actor does that when you turn on Search each day separately.

For the example I typed Nvidia, picked September 21 to 27, 2026, and set Maximum articles to 300. You don't need a Google account or an API key. You do need an Apify account to run the Actor. The same input as JSON:

{
  "queries": ["Nvidia"],
  "edition": "US:en",
  "startDate": "2026-09-21",
  "endDate": "2026-09-27",
  "splitByDay": true,
  "maxArticles": 300
}

That run returned 276 articles instead of about 100, each with the headline, the publisher, the publish time and a link.

What the week looked like

Counted by publish day (in UTC), Friday was the busiest, with 64 articles. By publisher, Yahoo Finance alone ran 73 of the 276.

One honest caveat: each day's search also returned Google's maximum of 100 entries, so the run report marks those days as possibly incomplete. More articles may exist. Splitting by day gets you much closer to the full picture, but for a name this busy it isn't a guarantee of every article.

Publisher links

Google News links point back to Google, not to the article. Where it can, the Actor turns them into the publisher's own link, and a link status column tells you which ones it found. In this run, 85 links were turned into the publisher's page and 191 kept the Google News link, because Google limits how many links can be looked up in a row. The Google link still opens the article; it just takes one extra hop.

Follow the topic after the first run

To keep up with a topic without getting the same headlines again, turn on Only articles not saved before and give it a Watch name. Later runs with the same watch name return only articles that weren't delivered before. Save the input as a task and schedule it daily or weekly.

{
  "queries": ["Nvidia"],
  "timeRange": "day",
  "newOnly": true,
  "watchName": "Nvidia news"
}

I wrote more about that setup in a small news watchlist that doesn't send the same headlines every day.

Export and cost

Export the Articles view as CSV or Excel. The run report shows what every search returned, including which days hit Google's limit.

The price is $0.95 per 1,000 saved articles, with no start fee and platform usage included. The 276 articles above cost about $0.26 at base prices. Check the Pricing tab for your account's rate, and set a spending limit before larger runs.

Questions or a reproducible problem: use the Actor's Issues tab or email contact.cleanscrape@gmail.com. CleanScrape is independent of Google and Apify, and Nvidia is used here as a public-news example, not an endorsement.

pytrends keeps failing with 429 errors? Here's a one-line fix

CleanScrape — Sun, 04 Oct 2026 14:04:04 +0000

If you have a Python script that pulls Google Trends data with pytrends, there's a good chance it stopped working. pytrends was archived in April 2025, and most requests now end in 429 Too Many Requests.

I built trendreq to fix that without rewriting anything. It has the same TrendReq class and returns the same DataFrames, but the requests run on my Google Trends Actor on Apify, where the proxies and retries are handled for you. I'm the developer, so this is a walkthrough of my own tool, not an independent review. An AI agent wrote it from a real run, and the output below is from that run.

Why pytrends gets 429s

Google Trends has no official public API (Google's own is still a closed alpha). pytrends talks to the same internal endpoints the website uses: one request for a short-lived token, then one per chart. Every request comes from your IP address, and Google limits how often one address can do that. A loop over a few dozen keywords is usually enough to get blocked for a while.

The usual advice is sleeping between calls, rotating proxies yourself, or patching the library. That works for a bit, then it doesn't.

The change

# from pytrends.request import TrendReq
from trendreq import TrendReq

Install it and set your Apify token (a free Apify account includes $5 of usage a month):

pip install trendreq
export APIFY_TOKEN=your_token

Everything else stays the same:

pytrends = TrendReq(hl="en-US", tz=360)
pytrends.build_payload(["iced coffee", "cold brew"], timeframe="today 12-m", geo="US")

over_time = pytrends.interest_over_time()
by_state = pytrends.interest_by_region(resolution="REGION", inc_geo_code=True)
related = pytrends.related_queries()

What came back

interest_over_time(), the last few weeks:

            iced coffee  cold brew  isPartial
date
2026-09-06           57         63      False
2026-09-13           59         68      False
2026-09-20           47         51      False
2026-09-27           42         49      False
2026-10-04           32         33       True

interest_by_region(), sorted by cold brew. Oregon and Washington lean hardest toward cold brew:

           geoCode  iced coffee  cold brew
geoName
Oregon       US-OR           31         69
Washington   US-WA           35         65
Kansas       US-KS           35         65
Montana      US-MT           36         64
California   US-CA           37         63

And the rising related queries for cold brew, which is where product ideas tend to show up:

                                 query  value
0      toasted coconut cream cold brew  19700
1           smores cold brew starbucks  19700
4    how to make cold brew concentrate   2050

The whole thing took one run of about 9 seconds.

One run instead of three

Each method call starts one Apify run, and each run has a small start fee. If you want several data types for the same keywords, ask for them together:

pytrends.fetch("interest_over_time", "related_queries", "interest_by_region")

After that, the three methods read from the same run. The example above did exactly that: 102 rows, about $0.36 at the base price.

What's different from pytrends

Most of it works the same, but not all of it:

Related topics come back empty. Google currently returns an empty list for automated requests (pytrends gets the same), so related_topics() gives None with a warning. Related queries work.
City results get coordinates. interest_by_region(resolution="CITY") adds latitude and longitude, because the US has several Springfields and they shouldn't merge.
US metro areas work with resolution="DMA".
gprop isn't supported yet, so YouTube, News and Shopping search raise a clear error instead of returning web data.
suggestions() and categories() aren't there yet. They raise NotImplementedError with a short explanation.
Trending searches (trending_searches, today_searches) work, and trending_now("US") adds approximate traffic and related news headlines.

The exception names are the same, so except ResponseError: blocks keep working.

Cost

You pay Apify for the Actor's rows: $0.05 per run plus $0.003 per row at the base price, less on paid plans. Two keywords over 12 months is about $0.37. Today's trending searches for one country is about $0.08. The free monthly credit covers a few dozen typical calls.

Try it

Code, docs and offline tests: github.com/CleanScrape/trendreq
The Actor it runs on: apify.com/cleanscrape/google-trends-scraper

If something you rely on in pytrends doesn't work, open an issue on GitHub. I'd rather hear about it and fix it.

How Sinner won Wimbledon 2025, in break points

CleanScrape — Sat, 03 Oct 2026 20:01:09 +0000

The scoreline of the 2025 Wimbledon men's final says Jannik Sinner beat Carlos Alcaraz 4-6 6-4 6-4 6-4. It doesn't say how. For that you need the match statistics, and for a whole tournament you need them in one table, with the counts behind every percentage.

I built CleanScrape's Tennis Scraper API to get that table from Flashscore. I'm the developer, so this is a walkthrough of my own tool, not an independent review. An AI agent wrote this walkthrough from my run, and every number in it was checked against that run.

One line of input

Open the Actor and type Wimbledon 2025 into Tournaments, players or matches. Set Maximum matches to 500 and start.

You don't need a Flashscore account, cookies or an API key. You do need an Apify account to run the Actor. The same input as JSON:

{
  "targets": ["Wimbledon 2025"],
  "maxResults": 500
}

The list takes other things too: a player (Sinner 2026), a draw (US Open women 2024), a common name (Roland Garros 2024) or any Flashscore link. The run report says how each line was read. Mine said: "Wimbledon 2025" was read as ATP Wimbledon 2025, WTA Wimbledon 2025.

What came back

478 singles matches, men's and women's, qualifying included. Each row has the round, the score with tiebreak points (7-6(2) 6-4 6-4), the status (finished, retired and so on), the match time, the umpire and the match statistics. All 478 had full statistics. The run took about nine minutes.

The statistics keep their counts. You don't just get "first serve points won: 75%", you get firstServePointsWonHome = 54 and firstServePointsPlayedHome = 72. That matters as soon as you add matches together, because you can't average percentages from matches of different lengths.

Adding it up

I took the men's main draw and summed each finalist's serve numbers over their seven matches:

	Service games held	Break points faced	Break points saved
Sinner	93 of 99	23	17
Alcaraz	118 of 133	57	42

Sinner faced fewer than half as many break points as Alcaraz over the fortnight. In the final itself he saved 4 of 6.

Two caveats. Sinner's fourth-round match against Grigor Dimitrov ended in retirement with Dimitrov two sets up, so it counts with the statistics of the part that was played. And seven matches against different opponents isn't a controlled comparison. It's a description of how the two got through the draw, not a ranking of servers.

Point-by-point, form and head-to-head

Two switches add more. Point-by-point gives every game: who served, who won, whether serve was broken, and every point score with break points, set points and match points marked. The last game of the final went 15-0, 30-0, 40-0, 40-15, with match point flagged on the last two.

Form and head-to-head adds each player's latest matches, overall and on the surface, and their earlier meetings. It's meant for matches coming up. For a past match, the form lists are what Flashscore shows today, so they can include later matches. The row says so.

Export and check the report

Click Export, pick the Statistics view and download CSV or Excel. Use JSON when you want the nested data: per-set statistics, point-by-point and the form lists. Keep ID columns as text.

The run report shows how each line was read, how many matches it listed, matched and saved, how many had full, basic or no statistics, and why the run stopped.

Use it on what you actually care about

One tournament, several years: Wimbledon, with Editions per tournament at 5.
A player's season: Swiatek 2025, with point-by-point if you want it.
Yesterday's results: leave the list empty and pick Yesterday.
Upcoming matches: leave the list empty, pick Next 3 days, status Scheduled, and turn on form and head-to-head.

There are ready-made examples for Wimbledon 2025 with statistics, yesterday's results, upcoming matches with form and head-to-head and a player's season with point-by-point.

Cost and limits

The base price is $1.00 per 1,000 matches. Match details (statistics, set details or point-by-point) add $1.50 per 1,000, and form and head-to-head add $0.50 per 1,000, both only when Flashscore has them for that match. The Wimbledon run above, 478 matches with statistics, comes to about $1.20 before tier discounts. Check the Pricing tab for your account's rate and set a spending limit for big runs.

Coverage follows Flashscore. ATP, WTA, Challenger and Grand Slam matches have full statistics. Most ITF matches have scores but few or no statistics. Bookmaker odds and rankings aren't included, and live matches are a snapshot at collection time.

If you work with an AI assistant, there's also a free tennis research skill that explains the fields and how to add statistics up without mixing percentages.

Questions or a reproducible problem: use the Actor's Issues tab or email contact.cleanscrape@gmail.com. CleanScrape is independent of Flashscore, the ATP and the WTA.

Read the comments before you pay for Likee reach

CleanScrape — Sat, 03 Oct 2026 10:00:12 +0000

Say you're about to pay a Likee creator to reach people in the United States. Views and likes tell you that something was watched. They don't tell you who watched it. The comments are a better clue, because people write them in their own language and about their own concerns.

I built CleanScrape's Likee Scraper API to get those comments into a spreadsheet. I'm the developer, so this is a walkthrough of my own tool, not an independent review. An AI agent wrote this walkthrough from my run, and every number in it was checked against that run.

Start with a creator's recent videos

For the example I used Likee's official US account, @likee_usa. Open the Actor, paste the handle into Creators or video links, choose Videos and set Maximum results to 10.

You don't need a Likee account, cookies or a separate API key. You do need an Apify account to run the Actor. The same input as JSON:

{
  "targets": ["@likee_usa"],
  "mode": "videos",
  "maxResults": 10
}

The Videos view puts each caption beside its publish date, views, likes, comment count and shares. In my run, the post with the most discussion was "Real or Mini?", with 114 comments. That's the one I wanted to read.

The counts are what Likee showed at collection time. Some come from share pages, which round them (5.90K). The countPrecision column tells you which ones are exact.

Then read the comments

Copy the video's link (in the Likee app: Share > Copy link), paste it into the same field, switch to Comments and ask for 40.

{
  "targets": ["https://likee.video/@likee_usa/video/7629882278902002999"],
  "mode": "comments",
  "maxResults": 40
}

Here's what came back. 22 of the 40 comments were in Russian. One more was in Tajik. The most-liked comment, with 37 likes, was "В лайке есть сша?!", roughly "Is there a USA on Likee?!".

That doesn't prove where the viewers live. Language is a clue, not a location, and 40 comments from one video is a small sample. But if you were budgeting for an American audience, it's the kind of thing you want to see before paying, not after.

A note on counting: I first counted 24 comments in Cyrillic and nearly wrote "24 in Russian". Two of them weren't. If you do this check yourself, classify the language, not just the alphabet.

Export and check the report

Click Export, pick the Comments view and download CSV or Excel. The Comments view includes the text, public author name, date, likes and the video each comment belongs to. Keep the ID columns as text when you import, so spreadsheets don't round the long numbers.

Then open the run report. It shows how many comments were read, which inputs were checked and why the run stopped. In this run it stopped because it reached the 40-comment limit, not because the video ran out of comments. A finished run is not a complete history of a video's comments, and hidden or removed comments can't be collected.

Use it on the creator you're actually considering

Replace the official account with the creator you're thinking about paying. A few setups that work well:

One creator's recent posts: their handle, Videos, 10 results.
Comments on one post: its Share link, Comments, 20 to 40 results.
A sample across several posts: their handle, Comments, Videos per creator 3 and Comments per video 15. Maximum results is the total for the whole run, so set it to 45.

There are two ready-made examples using Likee's own accounts: compare two official accounts and read a comment sample.

Cost and limits

The base price is $1.95 per 1,000 saved videos or comments, with no startup fee. The 40-comment run above costs $0.078 at that rate, before any tier discount. Check the Pricing tab for your account's rate, and set a spending limit before larger runs.

It collects public videos and comments only. There's no keyword or hashtag search, no private content, and no guarantee of a complete history. The maximum you set is a ceiling, not a promise that the source has that many.

If you work with an AI assistant, there's also a free Likee research skill that explains the fields and how to do this kind of comment check without overclaiming.

Questions or a reproducible problem: use the Actor's Issues tab or email contact.cleanscrape@gmail.com. CleanScrape is independent of Likee.

A small news watchlist that doesn't send the same headlines every day

CleanScrape — Sun, 27 Sep 2026 17:56:29 +0000

A recurring news export has an annoying failure mode: it works, but keeps handing you the same headlines.

For CleanScrape's news Actor, I wanted a small watchlist to answer two separate questions: which available articles match my topic, and which of those have I not received before?

I maintain Google News and Publisher Feed Scraper. It is a paid Actor that collects Google News searches and public publisher feeds into an article table. It does not generate summaries or read through paywalls.

Get a useful first export before adding a schedule

Open the electric-vehicle example. It looks for recent electric-vehicle news, with a maximum of 20 articles.

In the form, choose the Google News edition and Published within from the dropdowns. You do not need to remember a country code or type dates in an exact format.

For an API call, the same small starting point is:

{
  "queries": ["electric vehicles"],
  "edition": "US:en",
  "timeRange": "week",
  "maxArticles": 20,
  "resolveUrls": true
}

Open Articles to inspect the headlines, publishers, dates and links. Any summary text is an available feed snippet, not the full article body.

Narrow the topic without a complicated search expression

For a more focused watch, you could keep headlines containing recall or battery fire and exclude opinion:

{
  "queries": ["electric vehicles"],
  "includeTerms": ["recall", "battery fire"],
  "excludeTerms": ["opinion"],
  "includeMode": "any",
  "filterScope": "headline",
  "timeRange": "week",
  "maxArticles": 20
}

These are literal word or phrase filters, not an AI judgement about whether an article is important. They do not search full article bodies. No result can simply mean that none of the available entries matched.

The Actor can also read public RSS, Atom and JSON feeds. There is a separate BBC Technology feed example if you want to start with a known publisher instead of Google News.

One distinction is easy to miss: a Google search query does not filter a publisher feed added to the same run. The word filters apply across sources; the query itself does not.

Then stop exporting the same articles every time

Enable Return only previously undelivered articles and enter a stable Watch name. For the original broad search, that looks like:

{
  "queries": ["electric vehicles"],
  "edition": "US:en",
  "timeRange": "week",
  "maxArticles": 20,
  "newOnly": true,
  "watchName": "EV industry watch"
}

The first run exports eligible entries. Later runs using the same watch skip article identities already delivered to it. A repeat run with no new output can be doing exactly what you asked.

Keep the watch name, sources and filters consistent. Use a new watch name when changing the scope. Delivery history is retained for up to 90 days, subject to storage availability; this is not a permanent archive or a system for tracking edits inside articles.

To run automatically, save the configuration as an Apify task and add a schedule. Turning on the watch option does not create that schedule, send an email or post to Slack. Those are separate workflow steps.

Two things I would check before using the export

First, read Run report. Feed limits, date filtering and source errors can all reduce the output. Twenty is a maximum, not a guaranteed count. If each publisher must contribute, separate runs can be better than letting the first source fill a shared cap.

Second, check link status. Publisher-link lookup is best effort. If it cannot resolve a direct URL, the row retains its Google News link and reports that status. It is still a delivered, billable article. This is more useful than silently dropping the headline, but it matters if your next step requires direct publisher URLs.

At the current base price, 20 delivered articles cost $0.019, with no startup fee. The examples have a $0.05 spending cap. Previously delivered watch entries and filtered-out entries do not generate article charges.

The intended result is a manageable reading queue for your own research or reporting workflow. It is not a complete news archive, a verified factual briefing or a substitute for reading the source.

CleanScrape is independent of Google and the publishers. Public feed availability does not grant unrestricted republication rights. Questions or reproducible issues are welcome in the Actor's Issues tab or at contact.cleanscrape@gmail.com.

Make a reading brief from the saved articles

The Google News and feed research skill covers what happens after export. It helps a compatible assistant organise the available headlines and snippets into a sourced reading list, without presenting feed text as a full article or a verified account of events.

Use this article export only. Group the main topics, keep publisher links and dates, and flag unresolved links or missing context. Do not fetch full articles or start another run.

The instructions are free and do not create a schedule. Fresh collection and any assistant usage have their own costs. Keep the underlying sources handy when a detail matters.

A Shopify review is not always about the product page you're looking at

CleanScrape — Sun, 27 Sep 2026 17:55:24 +0000

One detail worth checking before analysing Shopify reviews: the reviews displayed on a product page may not all belong to that exact product.

During validation of CleanScrape's review scraper, one clothing product widget exposed 675 reviews. The source flagged 619 of them as shared from its product group. Treating that whole export as feedback about a single item would have given the wrong impression.

That is why I wanted product attribution in the output, not just a rating and a block of text. I maintain Shopify Product Reviews Scraper, a paid Actor that currently supports public Judge.me and Okendo integrations.

Video walkthrough (added October 5, 2026): the same check on Magic Spoon's Strawberry Cheesecake cereal page, where only 56 of 1,000 reviews are about that cereal.

Start with one product URL

Open the 25-review example. It uses an Owala product page. Replace that URL with the product you want to investigate.

You do not need to identify the review provider, find a shop ID or supply a merchant API key. The Actor checks the public integration and reports which supported source it found.

Here is a small API input that keeps all star ratings:

{
  "productUrls": ["https://owalalife.com/products/freesip"],
  "maxReviewsPerProduct": 100,
  "maxTotalReviews": 25,
  "ratings": ["1", "2", "3", "4", "5"]
}

In this configuration, 100 is the per-product scan budget and 25 is the total export limit. They do different jobs.

Filtering low ratings does not search the whole history

Suppose you change ratings to ["1", "2"] while keeping the scan budget at 100.

The Actor exports matching reviews found within those scanned records. It does not promise to keep searching until it finds 25 low-rated reviews. Eight matching rows, or none, can be a valid result.

I would first export a small unfiltered sample to check the content and attribution, then narrow the ratings. Otherwise it is easy to mistake a restrictive filter for a broken source.

Keep the attribution columns in your spreadsheet

Open the review output and inspect Product attribution alongside the review text. These fields are particularly useful:

Field	Why it matters
`productUrl`	The product page requested
`reviewedProductName` and `reviewedProductUrl`	The reviewed product identified by the source, when supplied
`isGroupedReview` and `isBundleReview`	Available grouping context; null means it was not established
`provider`	Whether the row came from Judge.me or Okendo
`recordKey`	A stable key for joining your exports

For a product-feedback analysis, I would separate clearly shared reviews from product-specific feedback and keep unknown attribution as its own category. I would not quietly turn unknown into false.

Once the columns make sense, export CSV, Excel or JSON. The Actor collects the reviews; it does not perform sentiment analysis or decide which complaints matter to your business.

Check what the source actually exposed

The Coverage report records the source, scanned and exported counts, and why collection stopped. A successful run does not establish that the full review history was available.

Some integrations expose only embedded reviews or stop pagination early. An unsupported source is not proof that the product has zero reviews. Missing titles, dates or verification badges stay missing rather than being guessed.

Support is currently limited to recognizable public Judge.me and Okendo integrations. A Shopify store using another review app is not covered just because it runs on Shopify. This also does not collect Shopify App Store app reviews.

The current base price is $0.95 per 1,000 exported reviews, with no startup or rating-filter add-on fee. A 25-review export costs $0.02375 before subscription discounts. The example has a $0.05 cap. A fresh run can return and charge for reviews collected in an earlier run; this is an export tool, not a changes-only monitor.

If you are combining reviews across stores, the attribution is worth keeping even when it complicates the spreadsheet. It is better to see that uncertainty than to build a neat analysis around the wrong product.

CleanScrape is independent of Shopify, Judge.me, Okendo and the merchants used as examples. For a reproducible issue, share a run ID and public product URL through the Actor's Issues tab or contact.cleanscrape@gmail.com.

Keep that distinction when using an assistant

I added a Shopify review research skill for this part of the workflow. It tells a compatible assistant to retain Judge.me or Okendo attribution, separate shared product-group reviews, and keep unknown scope visible rather than quietly treating every row as exact-product feedback.

Analyse this saved review export. Separate exact-product, shared and unknown attribution before summarising complaints. Show the review IDs behind each finding. Do not collect more reviews.

This works from your existing files. The skill is free; it does not make fresh Actor runs or your assistant's own usage free.

From Pinterest search to a usable research spreadsheet

CleanScrape — Sun, 27 Sep 2026 17:54:12 +0000

Pinterest is useful for finding ideas. Keeping track of the websites behind those ideas is a different job.

For a research project, I would rather have a small list I can inspect and revisit than a folder full of disconnected images. That is the workflow behind CleanScrape's Pinterest Actor: collect the public pins, keep the available source links, and make the result usable outside Pinterest.

I maintain the Actor, and it is a paid tool. This walkthrough uses home-office ideas as an example.

A focused search, rather than whatever looks vaguely related

Open the home-office example. It asks for up to 50 pins, selects All query words, and enables additional public pin details.

The matching setting matters. Pinterest can return broad recommendations. All query words requires the search words to appear in the pin's title, description or alt text. Exact phrase is stricter; Pinterest relevance is broader.

Neither strict option understands the image itself. A relevant desk setup can be excluded if its accompanying text never says "home office." That is a trade-off, not a reason to call the search exhaustive.

For a minimal API input:

{
  "searchTerms": ["home office"],
  "maxPins": 50,
  "searchMatching": "allWords"
}

The ready-made example also enables the additional public detail lookup. You do not need Pinterest cookies, a login or a numeric board ID.

Use the visual view before opening the spreadsheet

After the run, open Research view in Output, then the RESEARCH_VIEW record. It shows a visual preview of the first 200 exported pins, along with destination-domain counts for the export.

This is a convenient place to decide whether the search is useful before doing more work with it. If most results are off-topic, change the matching or filter settings rather than immediately increasing the limit.

The recorded 50-pin demo contained 13 external source links across 12 destination domains. That describes that run, not a guaranteed hit rate. Some pins do not expose an external destination at all.

Keep the Pinterest link and the destination link separate

For a spreadsheet, select Research essentials in the export dialog and choose Excel or CSV. Use All fields if you want the complete dataset.

The distinction I would preserve downstream is:

Field	What it points to
`pinUrl`	The Pinterest pin
`outboundUrl`	The external destination, if supplied
`outboundDomain`	That destination's domain

An empty destination is not a failed attempt to invent a website. It means the source did not provide one in the collected data. Similarly, a missing engagement count is not zero.

You can sort by domain to find recurring source websites, then open the links to check the original material. Domain frequency in one export is not evidence of market share or popularity across Pinterest.

A few limits worth keeping in the notes

The Actor accepts public searches, boards, profile feeds and individual pins. A profile feed can include saved pins; it is not necessarily a list of that person's original work. Private boards and comment text are outside the scope.

Image and video URLs are references, not a license to reuse the media. Saves, comments and shares are also not views, sales or demand estimates.

At the current base rate, 50 delivered pins cost $0.0625, with no startup or separate detail-lookup fee. The example has a $0.10 spending cap. Check Run report for filtering, source failures and stopping reasons if fewer pins arrive than requested.

The point is to get from a visual search to a research list you can actually work through. The same steps work with your own topic; home offices just make the process easy to see.

CleanScrape is independent of Pinterest. If a public input behaves unexpectedly, the Actor's Issues tab is the best place to share the run ID and what you expected, without passwords or tokens.

Organise the research list with an assistant

I published a Pinterest research skill for turning the saved export into a more usable list. A compatible assistant can group destination domains and content themes while keeping missing destinations, attribution and engagement limits visible.

Use this pin export to make a home-office reading list grouped by destination website. Keep pins with no destination in a separate group. Do not download images or run another scrape.

The skill is free; your assistant may have its own usage charges. It does not grant rights to reuse the pin media, and a frequently appearing domain is not automatically a popular or authoritative source.

Comparing Google Hotels booking offers without losing the stay details

CleanScrape — Sun, 27 Sep 2026 17:48:44 +0000

Comparing hotel prices looks straightforward until the tabs stop agreeing. One quote is per night, another is for the whole stay, and a cheaper offer may have a different cancellation policy.

For CleanScrape's Google Hotels Actor, I wanted the export to keep the stay details beside the prices. A spreadsheet is only useful if you can still tell what each number refers to.

Here's a small London example, using a real run. I maintain this paid Actor under CleanScrape.

Start with five hotels

Open the London example. It is prefilled for a two-night stay, two adults and prices in British pounds. You can change the destination before running it.

In the form, use:

Place searches: hotels in London
When is the stay?: In 30 days
Number of nights: 2
Adults: 2
Price currency: British pound
Maximum hotel results for the whole run: 5

The example also has a $0.02 spending cap. The result limit is a maximum, not a promise that every search can supply that many hotels.

The recorded run returned five hotel rows and 133 organic booking-provider offers. It was collected on September 27, 2026, for October 27-29. Those are historical quotes, not prices you can necessarily book now.

Two tables, two different jobs

Hotel prices is the shortlist. It puts the hotel name, check-in, check-out, adults, currency, nightly price and stay total together. I would start there to remove options that clearly do not fit the trip.

Provider offers goes one level deeper: which booking sites supplied offers for each hotel, and what prices did they show?

Those provider rows are included in the hotel result. Expanding the provider table does not turn five hotels into 133 separately billed hotel results.

There is an important distinction here: the Actor verifies the stay context, but it does not establish that every offer is for an equivalent room. A refundable room and a non-refundable room should not be treated as interchangeable just because the dates match. Taxes and other terms can differ too. Confirm the final price with the provider.

The export step is easy to miss

Click Export, then select Provider offers again inside the dialog before choosing Excel or CSV. Selecting the table on screen is not enough to assume the export dialog has selected the same view.

Once downloaded, you can sort quotes within each hotel and work through the options. Keep the hotel, dates, guests and currency columns; they are the context that makes the comparison useful.

What this run does not establish

A place search samples the first source results page. Five returned hotels are not the five cheapest hotels in London, and they are not an inventory of the city.

Some offer lists can also be partial. Open Run report and read it alongside the dataset before treating an export as complete. The video deliberately leaves that coverage information visible.

At the current base prices, five delivered hotels and one start at the default memory cost $0.01075: $1.95 per 1,000 hotel results, plus $0.001 for that start. Subscription discounts may apply; check the Actor's Pricing tab before a larger run.

For me, the useful outcome is a shortlist with enough context to investigate, not a spreadsheet that pretends to make the booking decision. Try the small example first and see whether those fields fit your comparison.

CleanScrape is independent of Google and the booking providers. Questions or reproducible issues can go in the Actor's Issues tab or to contact.cleanscrape@gmail.com.

Compare the exported offers with an assistant

There is also a Google Hotels comparison skill for this step. It guides a compatible assistant to compare offers only within the right stay and currency, preserve the source totals, and point out where room terms or coverage still need checking.

Compare these saved hotel offers for the same dates, guests and currency. Show the lowest observed totals and explain which offers are not directly comparable. Do not collect new quotes or make a booking.

The instructions are free. Working with the export needs no new Apify run, although your assistant may have its own usage charges. The result is a shortlist to investigate, not a live booking quote.

Export App Store and Google Play reviews into one spreadsheet

CleanScrape — Tue, 15 Sep 2026 15:45:58 +0000

When an app is available on iOS and Android, I want to read the feedback from both stores without switching between pages. Are people raising the same issues, or does one platform need a closer look?

I built CleanScrape's App Store and Google Play Reviews Scraper to put those reviews into one table. This walkthrough uses my paid Actor to collect a small sample, then shows how to compare the comments in a spreadsheet. The comparison is something you do after export, not an automatic analysis feature.

Let's use Spotify as an example. You can replace its store links with those for your own app or another publicly listed app.

Watch the export workflow

The short demo shows the app links, regional settings, review table and spreadsheet export. It requests up to 20 reviews per store. The comparison steps below pick up where the video leaves off.

Get your first small export

Open the ready-made Spotify example. Its preset is 100 reviews per store; change Maximum reviews to 20 to follow the video.

Keep both stores selected. For another app, paste its Google Play and Apple App Store links into the corresponding fields.
Choose the country and Google Play language by name. The country selects a storefront, not the reviewer's verified location; the language setting does not translate comments.
Use newest reviews and keep the 1 GB memory setting. Set a spending limit before starting.
After the run, open Review essentials for the compact table. Open Run summary and field guide to check that both requested stores returned data.
Export CSV or Excel. Keep the source column in your spreadsheet.

The maximum is per store: 20 plus 20 means up to 40 reviews. Availability can produce fewer. If Apple supplies an unverified empty feed, the Actor now reports a source error rather than implying that the app has no reviews. A Google Play export can still succeed in that run, so read the per-store report before comparing platforms.

For an API workflow, the same small request is:

{
  "store": "both",
  "googlePlayAppId": "https://play.google.com/store/apps/details?id=com.spotify.music",
  "appStoreId": "https://apps.apple.com/us/app/spotify/id324684580",
  "country": "us",
  "language": "en",
  "maxReviews": 20,
  "sort": "newest"
}

Existing package names and numeric app IDs still work.

Compare the feedback, not just the averages

Start with a specific question, such as: Are the low-rated reviews describing similar problems on iOS and Android?

Filter rating to 1 or 2 and read the review text. Keep source, date and appVersion visible.
Add your own issue column. Use labels that fit the comments you actually read, such as sign-in, playback or billing. Those are possible labels, not findings from this sample.
Group or make a pivot table by issue and source, counting review IDs. This gives you a reading list of recurring themes in the downloaded sample.
Go back to the original comments before drawing a conclusion. A short negative review may not explain its cause. If appVersion is available, compare versions within each store, not as interchangeable iOS and Android release numbers.

This is not sentiment analysis, a satisfaction score or proof that one release caused a complaint. Twenty recent reviews per store can help you decide what to investigate; it cannot establish how common an issue is among all users. The two exports may also cover different date spans.

Know what the columns mean

Field	How I would use it
source	Keep iOS and Android feedback separate while using the same spreadsheet.
rating and text	Find comments to read, then understand the actual feedback.
date	Check the source timestamp; Apple's value is an update time, not necessarily the original publication date.
appVersion	Inspect version-specific feedback when the source supplies it. Missing versions stay empty.
reviewId	Identify reviews when joining or updating exports.
developerReply	Read available Google Play replies. Apple replies are not supplied by this feed.

Google Play titles are also empty in this adapter. Missing source fields stay empty rather than being filled with guesses. Choose the full Reviews view if you need every output field.

What the whole run costs

At the current base rate and 1 GB memory:

Delivered output	Result charges	Startup	Total
40 reviews	$0.008	$0.01	$0.018
200 reviews	$0.04	$0.01	$0.05

The second row is the existing preset if it returns 100 reviews from each store. Startup is charged even when no reviews return. Selecting more memory increases the startup charge; saved tasks can retain their own memory setting. Filtering rows in Excel does not change the number already delivered and billed.

These are base prices before subscription discounts, checked on 27 September 2026. See the Actor's Pricing tab for your applicable rate.

If you repeat the export

Apple's public feed is a recent, limited source, not a complete archive. Source availability can change. Increasing the maximum does not guarantee more history.

The Actor does not maintain review history across separate runs. Where a review ID exists, use the combination of source, appId, country and reviewId as a starting key. Update edited reviews instead of appending duplicates, and handle missing IDs separately.

Open the example, change the app links and keep the first run small. No store login or personal cookies are needed. CleanScrape is independent of Apple, Google and Spotify.

If you use review exports, what makes them useful after the download: comparing platforms, reviewing a release, or feeding another workflow? Practical feedback helps me choose what to improve. For a bug, open an Actor issue with the run ID and a non-sensitive input example. Keep tokens and credentials out of comments.

Use the same export in an assistant

I also published a free app-review skill for assistants that support agent skills. It gives the assistant a way to compare the two stores without losing the review IDs or mistaking a small sample for every user's opinion.

Use these saved review exports only. Compare iOS and Android complaints, show the rating counts for each store, and flag missing data. Do not start a new run.

You can also supply two snapshots to find newly observed or edited reviews. This is analysis of your files, not an automatic monitoring service. The instructions are free; fresh Actor runs and your assistant's own usage are separate.

Compare Google Trends terms in a spreadsheet without confusing interest with search volume

CleanScrape — Tue, 15 Sep 2026 15:44:55 +0000

I'm building CleanScrape for people who want to use web data in their own reports and tools. The Google Trends Scraper is one part of that: it returns Trends observations as rows you can export or retrieve through the API.

For this post, I'll compare ChatGPT and Claude in a spreadsheet. There is one detail I want to get out of the way first: a Trends value of 100 does not mean 100 searches. It is a relative interest score within the requested comparison. That meaning needs to survive the CSV export.

This walkthrough uses my paid Actor on Apify. I've included the cost calculation below so you can judge whether it fits your use case.

Watch a quick example

Let's use a coffee shop as an example. In this short demo, I compare "iced coffee" and "cold brew" in the United States over the past 12 months, export the timeline and plot the completed weeks.

The video shows the real input form, output table and export dialog. The chart is made separately from the exported rows, with the incomplete week left out. You can use the same steps for a personal interest, a business idea or a brand. The written example below uses ChatGPT and Claude over three months instead.

Request both terms together

This example compares ChatGPT and Claude in the US over the past three months. In the form, add both search terms, choose United States and Past 3 months, and select only Interest over time. If you prefer JSON input, use:

{
  "searchTerms": ["ChatGPT", "Claude"],
  "dataTypes": ["interest_over_time"],
  "geo": "US",
  "timeframe": "today 3-m"
}

You need an Apify account, but no Google login. The Actor uses residential Apify Proxy by default for these requests. It accesses Google Trends website endpoints; it is not Google's official API or an affiliated Google product.

I recommend starting with just the timeline. It keeps the output easier to read and avoids paying for result types you are not using yet.

Keep both terms in the same request. Pulling each term independently can give you separately normalized series that are not directly comparable. Also note that these inputs are search terms, not a guarantee that every search relates to a particular company or product.

Set a run spending limit and check the current pricing before selecting Start. You can also find this comparison as an example task on the Actor page.

Turn the rows into a chart

Once the run finishes, open Output and export CSV or Excel. Timeline rows include:

Field	How to use it
`keyword`	Separate the two series
`date`	Human-readable source date label
`timestamp`	Unix timestamp in seconds, returned as a string
`value`	Relative search interest
`isPartial`	Whether Google marks the interval as partial

In your spreadsheet, create a pivot table with date as the rows, keyword as the columns and value as the measure. Sort chronologically; if the imported date labels sort as text, convert them to dates or sort by the numeric timestamp first. Insert a line chart from that table.

Use the pivot only on the timeline rows. If you later request related queries or regional data, filter by dataType first. Those rows have different meanings.

The Actor exports data, not a finished chart. You choose the chart, title and interpretation.

Check the report before trusting the chart

Open RUN_REPORT in the run's key-value store. Each requested feature has its own status and row count. An empty result is not evidence that nobody searched for the term; a failed request is not a zero.

Google chooses the returned time intervals. Three months does not guarantee exactly 90 observations. A zero can reflect insufficient data, and a partial interval should not be presented as a completed period without qualification.

I would describe the chart as a comparison of relative search interest, not as a comparison of sales, active users or market share. The export cannot establish those things.

Count rows when estimating the cost

Each keyword at each returned timestamp is one billable row. If Google returns 90 timestamps for two terms, that is 180 rows.

At the base rate of $0.003 per row, those rows cost $0.54. Startup adds $0.05 per allocated GB, with a minimum of one startup event. At the current 1 GB default, the total for that example is $0.59 before subscription discounts. Existing saved tasks may retain a different memory setting.

That is a calculation, not a promised row count. Startup is charged even when no rows are returned, and other selected data types add their own rows. Subscription discounts can reduce the rates. Pricing and default memory were checked on 22 September 2026; use the Pricing tab for current figures.

If you are comparing tools, check the cost for the same task. One service may call an entire keyword history a result; another may count each observation. I do not want the per-result headline to obscure that difference.

Try your own comparison

Replace the two terms with a comparison relevant to your work, keeping the geography and time window consistent. Save the input alongside the export so you can explain what the chart measures later.

The Actor also supports related queries, regional interest and a current trending-searches feed. Related topics are optional and availability-limited: Google may return no topics even for familiar terms. I would not make a reporting workflow depend on that field always being populated.

The full documentation and example tasks are on Apify. I'd be interested to hear what you need after the export: a weekly comparison, a dashboard, or simply a file you can inspect. It helps me understand where the tool is useful and where the next bit of friction is.

Prepare the comparison with an assistant

If you would rather have an assistant prepare the table, I wrote a Google Trends research skill. It keeps the same checks from this post: one request context, timeline rows only, incomplete intervals labelled, and missing observations left as gaps.

Use this Trends export and its saved input. Make a chart-ready table for the two terms, exclude incomplete intervals, and explain what the scores mean. Do not collect fresh data.

The skill is free to use with a compatible assistant. It does not need another Apify run to analyse an existing file; your assistant may have its own usage charges.

Track "Map Your Show" exhibitor changes without comparing spreadsheets by hand

CleanScrape — Tue, 15 Sep 2026 15:43:37 +0000

I'm building CleanScrape as a small collection of practical data tools. With the Event Exhibitor Scraper and Change Monitor, I want to make one fairly specific task easier: export an exhibitor list, then see what changed without comparing the next spreadsheet by hand.

A new company, a different booth or an updated description can be useful information when you are planning an event visit or researching suppliers. But I do not want an incomplete download to look like dozens of companies disappearing. That is why the monitoring checks matter as much as the export.

I'll show a small snapshot first, then how to keep a baseline for later comparisons. This is a paid Actor on Apify. Its scope is public "Map Your Show" 8_0 directories on EVENT.mapyourshow.com, not every conference website. It does not provide attendee or hidden contact data.

Video walkthrough (added October 5, 2026): the same workflow on IAAPA Expo 2026, from an export of all 1,392 exhibitors to the changes between September 27 and October 4.

First, export a small list

Open the Actor in Apify and use this input:

{
  "eventUrls": [
    "https://iaapaexpo26.mapyourshow.com/8_0/explore/exhibitor-alphalist.cfm"
  ],
  "mode": "snapshot",
  "maxExhibitorsPerEvent": 100,
  "includeDetails": false
}

Review the Pricing tab and set a run spending limit before starting. This requests up to 100 exhibitors, with optional profile enrichment switched off. The IAAPA example depends on that edition's directory remaining public.

After the run finishes, open Output and export CSV or Excel. Rows include company names, booths, listing descriptions and source links where available. Booths are arrays in the JSON because an exhibitor can have more than one.

Open SUMMARY in the run's key-value store as well. A capped_snapshot is a deliberately limited sample, not a claim that you collected the entire directory. With optional details off, website and location fields can be null.

At the base rate, a snapshot returning 100 records costs $0.20, with no startup fee. I recommend starting here so you can see whether the fields are useful before setting up a recurring check.

Keep a baseline when you need comparisons

For monitoring, use a stable watchlist name and a source-record limit large enough for the whole directory:

{
  "eventUrls": ["https://iaapaexpo26.mapyourshow.com"],
  "mode": "monitor",
  "watchlistName": "iaapa-research-2026",
  "maxExhibitorsPerEvent": 5000,
  "includeDetails": false,
  "keywords": []
}

This is not another 100-row sample. The first complete monitoring run exports the baseline, and those rows are billable. A directory with 1,000 exhibitors costs $2.05 at the base rate for that first check, without optional details. A larger baseline costs more.

The Actor needs permission to create and access its named watchlist storage in the run owner's account. Reuse the same watchlist name and settings on later runs. You can save an Apify Task and add a schedule, but the input alone does not create one.

What a later run tells you

Later runs export changes rather than another copy of the baseline. Change records distinguish additions, updates and confirmed absence. For an update, changedFields tells you what changed, and before and after hold the compared values.

The following is an illustration, not a report about a real exhibitor:

Company	Previous booth	Current booth	Interpretation
Example Manufacturing	B12	C08	Booth field changed between checks

An unchanged directory can correctly produce zero change rows. The completed monitoring check still costs $0.05 per directory at the base rate. A check returning ten changes costs $0.07 without optional details.

Those prices are stated as of 15 September 2026, before subscription discounts. The Pricing tab has current rates. Optional enrichment is separately charged when enabled and public details are extracted.

Why I would not treat one missing result as a removal

The monitor requires a complete scan that reconciles retrieved IDs with the directory's reported total. Failed requests, overlapping pages and incompatible source responses must not silently become a new baseline.

A company is reported as no_longer_listed only after two consecutive complete checks miss it. Even then, that means it was no longer observed in the directory, not that it definitely withdrew from the event.

There is an additional guard against sudden mass disappearance: when a baseline has at least ten exhibitors and more than 40% disappear at once, the check is quarantined rather than advancing the baseline. Empty source directories are treated as unavailable.

I prefer that cautious behavior to a convincing-looking list of removals based on a failed fetch. It still has limits: the website can change between requests, and a change that happens and reverts between runs can go unseen. These checks do not make the snapshot perfectly atomic.

Before adding notifications

Run the workflow manually first and inspect SUMMARY. A run covering multiple events can have mixed outcomes. Monitoring supports at most 5,000 source records per event; optional details support at most 500 matched profiles per event.

A retry after interrupted delivery can repeat records, so use recordId for downstream deduplication. Do not assume exactly-once delivery. If you use keyword filters, a company leaving the matching scope is not necessarily leaving the directory.

Email, Slack and CRM actions belong in a separate integration; the Actor does not send messages or contact exhibitors. Start with the snapshot example, inspect the fields, and add monitoring only if you need it.

CleanScrape is independent of Map Your Show and the event organizers. Public availability does not remove the need to respect source terms and data-use restrictions.

I'd like to hear from people who actually work with exhibitor lists. Which changes affect your planning enough to be worth tracking: new companies, booth moves, updated descriptions, or something else?

Turn the export into a visit shortlist

For the next step, I published a Map Your Show research skill. A compatible assistant can use the saved rows to build a sourced shortlist or explain a changes export while keeping different events and incomplete checks separate.

Use this exhibitor export to shortlist companies mentioning packaging. Keep every booth, show the matching evidence, and leave unknown details blank. Do not run another scrape.

The skill does not find private attendee details or create a schedule. Its instructions are free. New Actor runs and any assistant usage are billed separately.