DEV Community: LMSlay

Alibaba reverse image search: a supplier CSV with price and MOQ

LMSlay — Fri, 23 Oct 2026 08:23:15 +0000

Disclosure: I build TubeText Labs' Alibaba & Yiwu Supplier Finder by Image. This is a documentation-based workflow, checked on October 23, 2026, not a new sourcing test or customer case study. The inputs and decision example below are illustrative.

You have a product photo and need a shortlist of wholesale listings, with minimum order quantity (MOQ), price and a link back to each supplier. Searching only by an English product name can miss the visual details you care about.

This walkthrough uses a product image to discover similar listings on Alibaba.com and Yiwugo, then turns the results into a reviewable CSV. It stops at candidate discovery: the matches do not establish who made the photographed item, whether the goods are identical, or which supplier you should pay.

Which Alibaba image search do you need?

There are two different jobs behind this search phrase:

Search an image collection you manage. Alibaba Cloud's Image Search documentation describes searching within a specified Image Search instance.
Discover supplier listings from a product photo. The TubeText Actor searches Alibaba.com and Yiwugo and returns listing and supplier fields. It is an independent Apify tool, not Alibaba's official API.

This article covers the second job. It does not search 1688, Taobao, JD or AliExpress. An AliExpress product can supply a reference image; that does not make AliExpress one of the supplier-search destinations.

1. Start with one public product image

In the Actor's Input tab, use Product image URLs, not the product page URL. Choose a clear photo of one item that you have permission to use and share. Avoid private customer photos or confidential designs.

Illustrative input, not ready to run: replace the placeholder with your permitted, publicly accessible image URL.

{
  "imageUrls": ["https://example.com/replace-with-your-product-photo.jpg"],
  "sources": ["alibaba", "yiwugo"],
  "maxResultsPerImage": 5,
  "language": "en"
}

Here, maxResultsPerImage limits matches per image and per source. Five is a small starting limit, not a promise that either source will return five usable candidates. English mode adds Yiwugo's English titles and shop names while retaining the Chinese originals; Alibaba.com results are documented as English.

The input supports separate price filters for Alibaba (minPriceUSD, maxPriceUSD) and Yiwugo (minPriceCNY, maxPriceCNY). For a first pass, leaving them unset can help you see whether the photo returns the right product category before narrowing on listed price.

When you choose to run it, review the current event pricing first. Each selected source is a separate image search. Match limits, extra-match events and Actor Start charges matter; fewer returned rows do not automatically mean the entire run is free.

2. Build a CSV that preserves the evidence

After a run finishes, inspect the dataset before exporting CSV or Excel. Keep JSON as well if you need array fields such as certifications.

The documented output fields support this shortlist:

Review question	Fields to keep	How to use them
Which image produced this candidate?	`input`, `sourceImage`, `scrapedAt`	Preserve the reference and observation time.
Where is the listing?	`source`, `productId`, `url`, `urlEn`	Use source plus listing identity, not the title alone. `urlEn` is for Yiwugo.
Is it visually relevant?	`title`, `image`, `rank`, `status`, `matchConfidence`, `similarity`	Open the listing and compare the item, not just its rank. `similarity` is Alibaba-specific.
What price is being advertised?	`price`, `currency`, `priceMin`, `priceMax`, `priceText`, `priceCNY`	Keep currency and any range or original text. Missing is not zero.
Does the order size fit?	`moq`, `moqUnit`, `moqText`	Check the unit and original wording together.
Who is behind the listing?	`shopName`, `shopUrl`, `supplierCountry`, `supplierProfileUrl`	Preserve the source links for later review. Some fields are source-specific.

All of these fields are optional in the public schema. Do not assume a complete row. Keep non-ok statuses and errors in a separate review tab instead of silently deleting them or treating them as a zero-priced offer.

Add your own columns for requested_quantity, variant_checked, unit_checked, review_decision and review_notes. These are reviewer-added columns, not Actor output. If you collect several photos, keep each image-to-listing relationship even when the same listing appears more than once.

3. Filter for MOQ before ranking by price

Suppose your intended order is 200 pieces. This is a made-up decision example, not returned data:

Candidate A has an MOQ of 1,000 pieces. A low displayed unit price does not make it suitable for the 200-piece brief.
Candidate B has an MOQ of 100, but its unit is boxes. Its quantity is not comparable until you know pieces per box.
Candidate C shows no price. Keep it as “quote needed,” not “free.”

Use the same checks on actual rows:

Open the listing and confirm that the photo match is the intended item, rather than a visually similar accessory.
Check variant, size, material and pack size. A shared image does not prove equivalent goods.
Compare MOQ only after resolving the unit. Preserve the original moqText when parsing is uncertain.
Compare advertised prices within the same currency and price basis. A low end of a range may not apply to your quantity or variant.
Record which candidates need clarification before they enter a price comparison.

Alibaba USD prices and Yiwugo CNY prices should not be sorted together as raw numbers. Even after currency conversion, a listing price is not a landed quote: shipping, packaging, duties, taxes, samples and payment terms still need separate confirmation. Subtracting it from a retail price does not establish profit.

4. Keep supplier verification separate

Alibaba-specific fields can include supplierYears, supplierRating, supplierReviews, goldSupplier, certifications and isAd. Yiwugo can include a market booth or location.

Use those fields to decide what to inspect, not as proof of manufacturing ownership, product quality or regulatory compliance. A certification label in a listing is not a verified certificate for your exact product and destination. A high visual score is not a supplier trust score.

The next stage is a reviewed specification, a supplier quote and, when appropriate, sample and document checks. This workflow does not contact suppliers, order samples or make a purchasing decision for you.

5. Already have an AliExpress product dataset?

The existing products-to-suppliers Python recipe first collects AliExpress product candidates, then passes that run's dataset to this image-search Actor. You do not need that first step if you already have a suitable image.

For an existing dataset, the supplier Actor accepts datasetId and maxDatasetItems. The schema describes using each product's main image and carrying its title, URL and price into the results. Check those images and cap the number of products before scaling. Dataset access may require the read-only permission shown by Apify.

The recipe's console output is deliberately minimal. Use the full supplier dataset for review, retaining source links, statuses, units and currencies as above. Its two Actor calls have separate event charges. The recipe was inspected for this article but not executed, and it has not been turned into a verified purchasing workflow.

Next step: open the Actor input, review the pricing, and start with one permitted product photo when you are ready. The useful first result is a small, traceable candidate list you can review, not a claim to have found the original factory.

Spotify play counts to CSV: compare your own snapshots

LMSlay — Fri, 23 Oct 2026 07:54:54 +0000

Disclosure: this tutorial is published by TubeText Labs, the developer of the Spotify Play Count Scraper. It describes an illustrative research workflow based on the public documentation checked on October 23, 2026. No new Actor run was performed for this article.

A music researcher following a group of releases needs a repeatable way to answer: what public counts did I observe last time, and what changed since then?

You can export Spotify track and artist metrics, save each collection separately, and compare matching records. The important part is keeping cumulative play counts, monthly listeners and missing observations distinct.

1. Choose a fixed set of links

Open the Actor and put public Spotify artist, album or track links in Spotify links (items). For a stable release panel, use explicit album or track URLs rather than assuming an artist's current popular releases will stay the same.

The current input schema also accepts playlist links, but limits maxPlaylistTracks to 100. It describes coverage as the tracks listed by Spotify's embed player. Do not treat a long playlist export as a guaranteed complete playlist.

For artist links, leave maxReleasesPerArtist at 0 if you only want artist summaries, including their top tracks. Setting it above zero requests additional popular releases and albums, with a schema maximum of 50 releases per artist. That expands the data collected and the billable album/track events.

Keep your link list and input settings alongside each export so you can tell a metric change from a change in collection scope.

2. Export the fields you actually need

Run the Actor when you are ready to incur its published charges, then open the output and export the Tracks, Artists or Albums view as CSV/Excel. Keep JSON too if you need nested fields such as cities or top tracks.

The documented output includes:

Track rows: type, status, url, name, playcount, artists, albumName and releaseDate. playcount is the cumulative track count, not a count for your research interval.
Artist rows: monthlyListeners, followers, worldRank, topCities and topTracks. World rank is documented for the top 500 only.
Album rows: label, totalTracks and totalPlays; the last is a sum of track play counts.

These fields are optional and nullable in the schema. Retain status and error, and never replace an unavailable value with zero. Top-city listener counts are location aggregates, not individual listener records or demographic profiles.

3. Preserve two separate snapshots

Save the first dataset and its run identifier. In your own research table, add an observation label, the run's collection window and an export timestamp in UTC. These are workflow metadata you add, not fields this article claims the Actor returns.

Later, repeat the same inputs and save a second dataset without overwriting the first. Match successful track rows by their documented Spotify url and type, after checking that the URLs refer to the same entity. Do not join only on a song title, and do not combine album totals with track counts.

In a spreadsheet or database, calculate:

observed change = later playcount - earlier playcount

Only calculate it when both matched rows have status = ok and numeric values. Leave unmatched or unavailable observations missing, and investigate duplicate records or negative differences rather than silently fixing them.

Call this change between observed cumulative counts. It is not an independently verified count of streams during a calendar day: collection times, source updates and missing observations can affect the comparison. A difference in monthlyListeners is a change in that reported metric, not a count of newly acquired listeners.

This workflow starts building your own history from saved observations. It does not backfill past counts, estimate royalties or establish why a metric changed. Availability and completeness can vary.

4. Budget for every event type

The live pricing page, checked October 23, lists Free-plan event rates of:

$0.001 per track ($1 per 1,000 track events).
$0.003 per artist report.
$0.002 per album summary, with its tracks charged separately.
$0.00005 per Actor Start event. The number of start events depends on allocated memory: one per GB, with a minimum of one.

For illustration, 20 chargeable track events, one album summary, one artist report and one start event add up to $0.02505. That is cost arithmetic, not a measured run or a fixed-price promise. Repeated snapshots incur their own events; higher Apify plans have different result-event rates. Check your selected plan before running.

The documentation describes failed or empty items as unbilled result rows, but that does not eliminate the separate start charge. Optional artist-release expansion can add album and track charges; the current public schema lists no AI option or AI event.

For a first research panel, keep the scope small and explicit. Export one observation, inspect the fields and missing values, then decide whether a recurring comparison would answer your actual research question.

Which comparison would you need: a fixed release panel, artist monthly-listener snapshots, or a playlist's changing membership? Those require different handling of scope and missing records.

Turn competitor video ads into an original creative brief, with source links

LMSlay — Thu, 22 Oct 2026 14:57:57 +0000

Disclosure: I maintain TubeText Labs, including the Video Ad Analyzer discussed here.

A folder of saved ads is useful until someone asks, “What should we actually make?” The missing step is a brief that separates what another advertiser did from what your own brand can honestly demonstrate.

Here is a small, review-first workflow. It uses an existing public sample and a hypothetical brief, not a newly tested campaign or a claim about conversion performance.

1. Keep the reference attached to the analysis

Video Ad Analyzer accepts Google advertiser names or domains, Meta brands or Facebook pages, existing video links, or an ad scraper's dataset. Its analysis includes the hook, persuasion angle, offer, CTA, transcript and shot breakdown.

For the downstream brief, keep three groups separate:

Source context: advertiser, original video or ad-library link, country and available dates.
Observations: what the opening shows, what the speaker says, what the offer includes.
Interpretation: why a hook might work, which audience it might address, what to test.

Do not turn a model's interpretation into a fact about sales. An ad being visible in a library does not establish its profitability.

2. Inspect a sample before spending anything

The Actor's README already includes a shortened Grammarly example. It shows source identifiers alongside a problem-led opening, an offer, a CTA and a shot count. Read that static sample first; there is no need to start a run to see the intended output shape.

If the fields fit your process, explicitly limit a later run. The input documentation lets you set the ads per brand and maximum video length. Also set Maximum cost per run in the run options. Avoid scheduling repeated collection before checking whether the first results are useful.

3. Write your own brief

The following is hypothetical, written for this article, and not Actor output. Imagine a desk-organizer brand whose approved product facts include removable dividers.

Audience problem: small desk items are difficult to find.
Opening concept: film your own untidy drawer, then show the same items arranged using the dividers.
Proof required: record the actual product in use, with no staged capacity or speed claim.
Message: explain the divider layout in your own words.
CTA: link to your actual product details; include only a currently approved offer.
Review gate: check product claims, footage rights, accessibility and destination before publishing.

The reusable learning is a problem → demonstration structure. Do not copy another advertiser's script, footage, music, identity or unsupported promises. Keep the reference link in your research notes so a reviewer can distinguish inspiration from source material.

This brief-writing step belongs to your team or a separately reviewed downstream process. The Actor does not provide an end-to-end video-production and publishing service.

4. Check quality and the full bill

AI analysis uses sampled frames and can miss context. Review the original video, advertiser match, offer conditions and relevant timestamps. Inspect row status before using a result; a completed run alone is not a quality check.

As of October 22, 2026, the pricing page lists Free-plan events at $0.05 per ad analysis, $0.01 per extra video minute, and $0.00005 for Actor Start. The README includes the first three minutes and bills additional started minutes. Meta discovery adds separate fetching charges; check the Meta fetching Actor's current pricing too. A waived analysis charge does not make the whole workflow free. Downstream AI or automation services can add their own costs.

Start with the public sample. Which missing brief field would make this useful in your review process?

A TikTok Shop API for public product data: price, units sold and stock per SKU as JSON

LMSlay — Sun, 18 Oct 2026 03:26:45 +0000

Disclosure: I build TubeText. This post uses our TikTok Shop Actor on Apify. The numbers below are from a run I did today.

If you search for a "TikTok Shop API", you mostly find TikTok's Partner/Seller APIs. Those are for managing your own shop: orders, listings, fulfillment. They won't tell you what a competitor's product costs, how many units it has sold or how much stock is left.

For that public product data, here's the one-call setup I use: the TikTok Shop Data API & Scraper on Apify.

One request: product and store links in, JSON out

curl -X POST "https://api.apify.com/v2/acts/tubetext~tiktok-shop-product-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"urls":["https://www.tiktok.com/shop/pdp/1729527313880355335","https://www.tiktok.com/shop/store/goli-nutrition/7495794203056835079"],"maxProductsPerListing":8}'

You can mix product links, store links and category links. A store link expands to its products, up to maxProductsPerListing. My run returned 8 products in 24 seconds, and the call waited and returned the rows directly.

What came back

The top rows from one supplement brand's store (US region):

Product (shortened)	Price	List price	Sold	Rating (reviews)
Ashwagandha & Vitamin D Gummy	$19.47	$24.70	1,305,110	4.5 (94,569)
Zero Sugar Best Seller Trio	$49.37	$74.10	1,036,888	4.4 (48,836)
3 Bottles of Ashwagandha & Vitamin D	$58.47	$74.10	865,774	4.7 (71,524)
3-bottle Best Seller Bundle	$49.37	$74.10	556,764	4.6 (41,460)

One product row, shortened:

{
  "productId": "1729527313880355335",
  "region": "US",
  "price": 19.47,
  "originalPrice": 24.7,
  "discount": "-21%",
  "soldCount": 1305110,
  "rating": 4.5,
  "reviewCount": 94569,
  "totalStock": 332597,
  "skus": [{"options": "Size: 1 Bottle", "price": 19.47, "stock": 332597, "available": true}],
  "freeShipping": true,
  "deliveryEstimate": "Oct 22 - Oct 25",
  "shopName": "Goli Nutrition",
  "shopFollowers": 601523,
  "shopSoldCount": 5791276,
  "charged": true
}

Three fields I find most useful for monitoring:

soldCount: diff it between two runs and you have units sold per day, per product.
totalStock and per-SKU stock: see which variant is running low, and when a restock happens.
price vs originalPrice: the discount depth. Here every product was 21–33% off its list price.

Choose listing cards or SKU-level stock details

For a single-product request and a short Python snapshot-diff example, start with the earlier TikTok Shop JSON quickstart. For the mixed product/store request above, choose the detail level before budgeting:

Need SKU stock, specifications, shipping and shop stats? Keep includeDetails: true (the default) for store/category products. Full-detail results cost $0.004 per product on the Free plan. The 8-product example has $0.032 in product-detail fees; 1,000 such results have $4 in product-detail fees.
Only need title, price, sold count and rating from a store/category listing? Set includeDetails: false. Listing cards cost $0.0015 each on the Free plan. Do not use listing-card mode when your workflow needs the SKU stock shown above. This setting applies to store/category products, not direct product URLs.

These are result-event prices, not a promise of the total run cost. Unavailable products and errors do not incur the product-detail fee; a row's charged flag is not an itemized run bill. Actor Start is separate, currently $0.00005 per event, with the event count based on memory (one per GB, minimum one). Check the current Pricing tab and itemized run charges; a run containing only failures is not guaranteed to cost zero.

Running it daily

Save the input as an Apify task, schedule it daily, and add a webhook to your endpoint. Each day's dataset is a snapshot you can diff. Or call it from n8n or Make with the Apify node. The data is US TikTok Shop and needs no login.

Questions or a field you need? Open an issue on the Actor's page. I read every one.

Reverse-engineer a creator's style: an AI persona and style guide from their latest videos

LMSlay — Sun, 18 Oct 2026 01:40:13 +0000

Disclosure: I build TubeText. This post uses our Video Breakdown AI Actor on Apify. The output below is from a run I did today.

When you study a creator, the useful question isn't "what is this video about?" but "what does this person do every time?": which hooks they open with, how fast they cut, what they sell, how they end. Answering that means watching a dozen videos with a notepad.

Here's how I get a first draft of that notepad from one API call: a persona and style guide built from a creator's latest videos, using Video Breakdown AI.

One call: a channel in, a style guide out

curl -X POST "https://api.apify.com/v2/acts/tubetext~video-breakdown-ai/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"urls":["https://www.youtube.com/@mkbhd/shorts"],"maxVideosPerSource":5,"accountSummary":true}'

The Actor takes the 5 newest Shorts, breaks each one down (hook, shot list, cut pacing, products shown, script), then condenses them into one extra row with "rowType": "account_summary". It works with a YouTube channel or an Instagram profile, and it needs at least 3 analyzed videos.

What came back for MKBHD's Shorts

The summary row, shortened:

{
  "rowType": "account_summary",
  "author": "Marques Brownlee",
  "videosAnalyzed": 5,
  "medianDurationSeconds": 66,
  "medianCutsPerMinute": 9.8,
  "medianShotCount": 11,
  "medianViews": 7170706,
  "accountSummary": {
    "content_pillars": [
      {"pillar": "Product Reviews & Deep Dives", "share_pct": 60},
      {"pillar": "Tech Industry News & Analysis", "share_pct": 20},
      {"pillar": "Concept & Speculative Tech", "share_pct": 20}
    ],
    "hook_patterns": [
      {"type": "visual surprise", "share_pct": 60, "example": "Hey Benny. Do a flip."},
      {"type": "bold claim", "share_pct": 40, "example": "All right, the folding iPhone is here. It's real. It's called the iPhone Duo."}
    ],
    "ctas": ["Get subscribed for more", "Watch the full video", "Follow for more"],
    "what_performs_best": "Videos featuring high-interest, 'impossible' tech concepts or viral-worthy hardware (like the iPhone Duo or Benny robot) significantly outperform standard industry analysis…"
  }
}

It also returns a persona, tone and voice, on-screen text style, products and brands, posting cadence, and a style guide of 5 to 8 rules. Three of the seven it wrote for this channel:

"Start with an immediate visual or auditory hook that defies expectations."
"Prioritize 'show, don't tell' by using high-quality B-roll to demonstrate features."
"Keep on-screen text minimal, using it only for critical data points or emphasis."

Two things I find more useful than the prose:

The hook mix is countable. 3 of 5 Shorts open on a visual surprise and 2 on a bold spoken claim. Run it on three competitors and you can compare those shares directly.
The medians give you a brief. About 66 seconds, about 10 cuts a minute, 11 shots. That's a concrete target for an editor, not "make it punchy".

The per-video rows are still there

Each of the 5 videos also gets its own row, so you can check the summary against the evidence. For example, the hook row for "Apple's Big Price Hike":

{
  "text": "All right, so the memory price hikes have finally hit Apple and they have really hit.",
  "type": "bold claim",
  "delivered_as": "voice",
  "why_it_works": "It immediately addresses a major tech news story with a sense of urgency and direct impact on the viewer's wallet."
}

Cost

Analysis costs $0.03 per video on the Free plan, plus $0.01 per additional started minute past 3 minutes. The account summary row has no separate fee during beta. For the five Shorts in this example, the analysis subtotal was about $0.15; the reported run took about 3½ minutes. Optional YouTube residential traffic and any Actor Start charge are additional. A failed download or analysis has no analysis-result fee, but that is not a promise that the whole run costs zero. Check the current Pricing tab and itemized run charges.

If a channel posts long videos, set "channelSort": "popular" to study its most-viewed uploads instead of the newest, and keep maxVideosPerSource small at first.

Caveats

5 videos is a small sample. The shares (60%, 40%) are counts, not statistics. Use 10 to 20 videos for anything you'll act on.
The persona and style guide are a model's reading of the videos. Treat them as a first draft to check against the per-video rows, not as fact.
Instagram profiles often hide view counts. When that happens, the summary says so instead of guessing what performs best.

Questions or a platform you need? Open an issue on the Actor's page. I read every one.

Idealo price API: compare shop offers across 6 European markets

LMSlay — Thu, 15 Oct 2026 01:37:13 +0000

Disclosure: I build TubeText. This post uses our idealo Actor on Apify. The sample prices below are from the original October 15, 2026 post, not live quotes. Documentation reviewed October 23, 2026; the sample was not rerun for this update.

For a retailer comparing competitor offers or a pricing analyst preparing a daily snapshot, the Idealo Price Scraper returns shop offers and a price summary as JSON, CSV or Excel. Start with idealo product links, product IDs or keywords, then choose Germany, Austria, France, Italy, Spain or the UK.

The Actor checks the supplied product ID in the selected markets and returns offers up to maxOffersPerMarket. Availability and offer counts can differ by market. Before treating two prices as comparable, review the offer title, variant, condition, currency and shipping terms.

Idealo API example: one product, three markets

curl -X POST "https://api.apify.com/v2/acts/tubetext~idealo-price-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"products":["https://www.idealo.de/preisvergleich/OffersOfProduct/202092559_-airpods-pro-2-apple.html"],"markets":["de","fr","it"],"maxOffersPerMarket":20}'

The original example contains 45 shop offers plus one summary row per market. These historical rows illustrate the output for Apple AirPods Pro 2; they are not today's prices or a speed guarantee:

Market	Offers	Shops	Lowest	Median	Highest	Lowest incl. shipping	Cheapest shop
DE	17	14	€183.00	€244.41	€387.99	€188.99	eBay
FR	10	8	€199.98	€246.26	€387.99	€199.98	Cdiscount.com (Marketplace)
IT	18	16	€195.99	€238.03	€387.99	€202.99	prezzoforte.it

Read these as summaries of the offers returned, not an exhaustive market census:

Keep price and shipping together. The sample German minimum is €183 before shipping and €188.99 including listed shipping. Check totalPriceWithShipping and the delivery destination; this field alone does not establish cross-border landed cost or account for every tax, duty or discount.
Keep the comparison consistent. The three sample medians are within €10 of each other, but one snapshot cannot establish price stability. Use the same product, market, currency and offer limit for repeated comparisons. UK prices are in GBP; the other five markets use EUR. Do not rank those raw numbers as if they were the same currency.

What an offer row looks like

{
  "type": "offer",
  "productName": "Apple AirPods Pro 2",
  "market": "de",
  "position": 1,
  "shopName": "eBay",
  "offerTitle": "Apple AirPods Pro 2 mit USB-C MagSafe Case",
  "price": 183,
  "shippingCost": 5.99,
  "totalPriceWithShipping": 188.99,
  "currency": "EUR",
  "deliveryTime": "Do. 15.10.–Di. 20.10.2026",
  "shopRating": 5,
  "shopReviews": 2012
}

Export competitor shop offers to CSV

If you need a spreadsheet of competing shops' offers, first distinguish that task from publishing your own catalogue. Idealo's merchant integration FAQ describes sending your product and offer data to idealo through its offer API or an exported feed. That merchant-upload workflow does not answer the competitor-read question here. TubeText's Actor is a third-party tool, not idealo's official merchant API.

Build a reviewable shop-level export

Use reviewed product links or IDs, select the markets, keep includeOfferRows: true, and choose a consistent maxOffersPerMarket. After a completed run, choose the Offers view and export CSV. If you export the mixed dataset instead, keep type: "offer" rows for the offer table and retain summary/error/no-offer rows separately. A summary row is not another shop.

Keep these columns from the documented output. Fields are optional; a column name is not a guarantee that every row contains a value.

Comparison column	Documented field	How to use it
Product reference	`productId`, `productName`	Preserve the reviewed input ID/link alongside the export. If an offer row lacks its ID, attach it only from unambiguous run context, never from a name-only guess.
Market and currency	`market`, `marketSite`, `currency`	Partition comparisons by market and currency.
Shop and offer	`shopName`, `offerTitle`, `offerUrl`	Retain the title and source link for variant, condition and offer checks.
Item price	`price`	Compare the item's stated price separately from delivery.
Shipping	`shippingCost`	Keep missing or unclear shipping unknown, not zero.
Listed delivered total	`totalPriceWithShipping`	Use only when the amount and delivery basis are comparable; this is not a guaranteed checkout or cross-border landed cost.

Add your own observation timestamp and run/dataset reference beside each export. These are bookkeeping columns you maintain, not timestamp fields promised by this output schema. Preserve position if useful, but do not use a changing rank as an offer identifier.

Worked example: item price and delivered price give different orders

Everything in this table is fictional: the shops, product and prices are invented to demonstrate a comparison, not collected results. Assume one reviewed product, the same variant and condition, market de, currency EUR, and the same delivery destination and terms. The labels below correspond to shopName, price, shippingCost and totalPriceWithShipping.

Fictional shop	Item price (EUR)	Listed shipping (EUR)	Listed delivered total (EUR)	Delivered-price treatment
Demo Shop A	189.00	8.00	197.00	Comparable
Demo Shop B	192.00	0.00	192.00	Comparable
Demo Shop C	188.00	Unknown	Unknown	Retain, but do not rank

Sorting item prices gives C, A, B. Sorting the comparable delivered totals gives B, A, with C unresolved. B is the lowest known delivered total among these rows, not a proven cheapest offer across all shops. C's missing shipping must not silently become free delivery. In CSV, leave unknown numeric cells empty and add a separate review/status note; do not insert a numeric zero or mix the word “Unknown” into a numeric calculation.

Where price and shipping are both explicit, you can check their sum against the returned total. If values conflict, or shipping terms are unclear, flag the row for source review rather than silently replacing the returned value. The current input caps returned offers at your selected limit, so this table describes the collected set, not every seller in the market. EUR totals from different countries still need delivery, tax and product checks; GBP and EUR require a recorded exchange-rate date and conversion method before any cross-currency ranking.

Compare two snapshots you collected yourself

Save both original exports, their collection times and run references. Keep the reviewed product list, markets and offer limit consistent. A later keyword search can select different products, so it is not a substitute for a fixed-product watchlist.
Match the product and market, then review the shop, offer title and source link for the same variant, condition and delivery basis. The Actor's FAQ says marketplace offers are recorded under the marketplace name; individual seller names are not collected. The schema does not document a durable seller ID or offer ID. Do not merge all rows named eBay, or assume an unchanged title/link proves the same underlying seller. Keep ambiguous matches unresolved.
Calculate changes only for reviewed matches with comparable values at both times. For example, if fictional Shop B changes from item 192 + shipping 0 = 192 EUR at observation A to 190 + 5 = 195 EUR at observation B, its item price fell by 2 EUR but its delivered total rose by 3 EUR. If Shop C has a total only in the second snapshot, its delivered-price change remains unknown.
Label unmatched rows “newly observed,” “not observed in this snapshot” or “needs review.” Missing rows, errors or a position outside the offer limit do not prove a shop stopped selling, and they are not zero prices. Compare each offer separately before summarizing the market.

This builds history from your own saved observations. It does not retrieve earlier dates you never collected, establish native historical backfill, or make a run-completion webhook into a price-change alert. The comparisons are downstream work in your spreadsheet or database. No new Actor run was performed for this worked example; review the cost below before collecting your first small snapshot.

Cost

As verified on October 23, 2026, the Apify Free-plan rate is $0.003 per delivered product-market, including its summary and shop offers up to your selected limit. Three delivered product-markets therefore incur $0.009 in result-event fees; 1,000 products in two markets incur $6 in result-event fees if all 2,000 checks deliver results.

Actor Start is additional: $0.00005 per GB of allocated memory, with a minimum of one event. At the current default 512 MB allocation, that is $0.00005 per start. A market with no offers has no product-market result fee, but that does not make the whole run free. Check the current Pricing tab for your plan and any other applicable account or service charges before scheduling.

If you only need the price summary, turn off offer rows (includeOfferRows: false); billing remains per product-market. Without product links, searchQueries discovers top matches on idealo.de. Review those matches before using them for a fixed-product comparison.

Running it daily

Save a reviewed input as an Apify task and use an Apify schedule when you need recurring snapshots. Keep each run's dataset and collection time so your own spreadsheet or database can compare dates. A run-completion webhook reports that a run finished; detecting a price change or sending a threshold alert requires downstream comparison logic.

Missing offers or failed rows should stay separate from comparable prices, not become a zero price or an assumption that nothing changed. Start with a small product list, inspect the source offers, and review the cost before enabling a recurring schedule.

Questions or a market you need? Open an issue on the Actor's page. I read every one.

Agoda reviews API: Booking.com reviews via Agoda and event costs

LMSlay — Tue, 13 Oct 2026 16:09:13 +0000

Disclosure: I build TubeText. This post uses our Agoda reviews Actor on Apify. The output examples below are from the original October 2026 article. Pricing and coverage notes were rechecked on 23 October 2026; this update does not report a new test run.

If you build a hotel reputation dashboard or a guest-feedback report, you need review text and source labels, not just an overall score. This Agoda reviews API returns Agoda reviews plus the Booking.com reviews that Agoda displays for the property. It does not read every Booking.com review directly, guarantee both sources for every hotel, or post replies.

Export Agoda reviews and Booking.com reviews shown on Agoda

The Agoda & Booking.com Hotel Reviews Scraper takes Agoda hotel links (or hotel IDs, or names) and returns one row per review, plus a hotel summary row. From a back end it's a single HTTP call to the Apify API:

curl -X POST "https://api.apify.com/v2/acts/tubetext~agoda-reviews-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"hotels":["https://www.agoda.com/the-peninsula-bangkok/hotel/bangkok-th.html"],"sources":["agoda","booking"],"sort":"recent","maxReviewsPerHotel":15}'

What comes back

The hotel summary row (shortened) has the score breakdown that dashboards usually chart:

{
  "type": "hotel",
  "hotelName": "The Peninsula Bangkok",
  "reviewScore": 9.2,
  "reviewsCount": 5314,
  "subScores": {"Cleanliness": 9.6, "Service": 9.5, "Facilities": 9.4, "Room comfort and quality": 9.3, "Location": 9, "Value for money": 9},
  "reviewSources": ["Agoda", "Booking.com"]
}

An Agoda review row:

{
  "type": "review",
  "source": "Agoda",
  "rating": 9.2,
  "title": "Always a great option",
  "text": "We have visited the Peninsula Bangkok multiple times as it never fails in quality...",
  "reviewDate": "2026-09-30T18:16:09Z",
  "stayMonth": "September 2026",
  "nights": 3,
  "travelerType": "Group",
  "roomType": "Grand Deluxe Room",
  "reviewerCountry": "Australia",
  "charged": true
}

A Booking.com review displayed on Agoda comes out in the same schema. Booking's "liked" and "disliked" fields are kept separately, which is handy for sentiment work:

{
  "type": "review",
  "source": "Booking.com",
  "rating": 10,
  "title": "Exceptional",
  "liked": "Complimentary boat ride to ICONSIAM every 30 minutes was so convenient",
  "reviewDate": "2026-09-16T17:00:00Z",
  "travelerType": "Solo traveler",
  "charged": true
}

Reviewer names aren't collected. You get the review content, the trip context (traveler type, room, nights, country) and the hotel's reply when there is one.

Cost breakdown: reviews, hotel summaries and optional AI

At the Apify Free-plan event rates checked on 23 October 2026:

Reviews: $1 per 1,000 delivered review rows.
Hotel summary: $0.003 per delivered hotel summary row.
Optional AI report: $0.05 per hotel, only when requested and delivered.
Actor Start: $0.00005 per event, with one event per GB of Actor memory and a minimum of one.

The original 15-review example corresponds to $0.015 for reviews + $0.003 for the hotel summary = $0.018 in result events, before the separate start event(s). Its reported 20-second runtime was one historical observation, not a speed guarantee.

For a volume example, 1,000 hotels × 20 returned reviews = 20,000 reviews, or $20. If each hotel also returns one summary, add $3: $23 in result events, before optional AI and start events. Enabling a delivered AI report for all 1,000 hotels would add $50. Higher Apify plans have different event rates; check the current pricing and the run's charge summary.

A status row marked charged: false has no result-event charge for that item. The separate start event may still apply, so an empty or unsuccessful result is not a promise that the total run bill is zero.

Turning reviews into a report

If you don't want to run your own LLM step, set aiInsights: true. It adds one English report per hotel (top complaints, praise and suggested actions) for $0.05 at the Free-plan event rate, using up to 300 reviews. The report describes the selected sample; complaint shares are not hotel-wide prevalence, and suggested actions need human review. For dashboards I'd still store the raw rows and summarize on your side, but it's a quick way to see whether the data answers your question before you build anything.

Scheduling it

On Apify you can save the input as a task, put it on a schedule, and add a webhook that calls your endpoint when the run finishes. Your service then fetches the dataset items by run ID. Keep the raw source, property identifier, review identifier when present, review date and collection time so the report can be traced back to its input.

Use sort: "recent" and startDate to restrict the review window. A date filter is not persistent cross-run deduplication: overlapping windows can return an already-seen review. Store and compare review identifiers in your own workflow, and decide how to handle edits or missing identifiers before sending alerts. Do not interpret a missing hotel reply as proof that a guest has never been answered elsewhere.

For a manual first look, export the Reviews and Hotels views as CSV or Excel. Keep review-source labels in the export, and do not combine the number of sampled reviews with the hotel's total review count as if they were the same measure.

Questions or a field you're missing? Open an issue on the Actor's page. I read every one.

Give your Dify workflows TikTok Shop, AliExpress and video transcript tools

LMSlay — Tue, 13 Oct 2026 15:09:52 +0000

Disclosure: I build TubeText and wrote this Dify plugin. It's free and open source. The tools bill per result to your own Apify account.

Dify is great at the LLM part of a workflow. The hard part is getting real data in: a product's sales and stock, AliExpress prices, or what a video actually says. The TubeText plugin adds four tools to Dify for exactly that. Each one runs an Apify Actor with your own token and returns clean JSON.

The four tools

Tool	You give it	You get
TikTok Shop Products	product, store or category links (US store)	price, discount, items sold, rating, stock per SKU, shop stats
AliExpress Search	up to 20 keywords	price, items sold, rating, ships-from country, Choice/deal badges
Video Transcript	YouTube and TikTok links, mixed	transcript per video (captions, or Whisper AI if you turn it on)
Get Run Results	a run ID	results of a long run, with paging

Setup (2 minutes)

Create a free Apify account and copy your API token from Console → Settings → API & Integrations.
In Dify, install TubeText from the Marketplace.
Open Tools → TubeText → Authorize and paste the token. A wrong token is rejected right there with a clear message, so you'll know immediately.

Workflow example: "what's the hook?" for any video

The simplest useful workflow has three nodes:

Start: one input, video_url.
TubeText → Video Transcript: map video_url into Links.
LLM: prompt it with the tool's text output, e.g. "Here is a short-form video transcript. Quote the hook (first sentence), name the selling points, and suggest a stronger hook."

The tool returns text (all transcripts joined, ready for the LLM node) plus json, which holds the items, the count, and each Apify run's ID and URL.

In my test, one call with one YouTube link and one TikTok link took 26 seconds. The plugin splits the links between the YouTube and TikTok Actors and runs both in parallel.

Workflow example: AliExpress price check by market

Add AliExpress Search with a keyword, a ship-to country and a currency. I tested Germany / EUR, sorted by orders, 3 results. You get one row per product with the price in that currency, items sold, rating and where it ships from. Feed that into an LLM node to write a short "price range and best seller" summary, or into a code node to flag products under a target price.

A detail that matters for price research: AliExpress shows big new-shopper discounts that most buyers never get. The tool flags these deals and sponsored results, and can skip them.

In an agent

Enable the TubeText tools in an agent app. Each tool has a description that tells the model when to use it. Prompts it's built for:

"Get the transcript of this TikTok and tell me what the hook is: [link]"
"Find yoga mats on AliExpress between $5 and $20, sorted by orders"
"How many units has this TikTok Shop product sold, and which variant has the most stock? [link]"

(I tested the tools in workflows on a self-hosted Dify. I haven't run agent mode with a model yet, so tell me if a prompt misfires.)

Long runs don't block your workflow

Each call waits up to Max Wait seconds (240 by default). If a run takes longer, say a whole YouTube channel, it keeps running on Apify, and the tool returns the run ID right away. Later, a Get Run Results node fetches the rows, with offset and limit for paging. I tested this with Max Wait set to 3 seconds: the tool returned RUNNING plus the run ID, and Get Run Results returned the finished data afterwards.

What it costs

The plugin is free. These are Apify Free-plan USD rates checked on 23 October 2026, not an all-in workflow quote. Dify/model-provider usage is separate.

Choose the commerce path before estimating the bill:

A US TikTok Shop stock review: TikTok Shop pricing is $4 per 1,000 products with full details. Store/category listing cards are $1.50 per 1,000 when Include Details is off, but those cards do not include per-SKU stock. For a per-variant review, keep details on and choose Full output: the plugin's Simplified field list retains total stock, not the SKU array.
An AliExpress price shortlist: AliExpress pricing is $2.50 per 1,000 search-result products. Start with one keyword, a fixed ship-to country/currency and a small Max Products per Keyword. Set Skip New-Shopper Deals explicitly; turn on Skip Sponsored if you want organic results. The Dify tool exposes search results, not the underlying Actor's separate product-detail mode.

Keep each platform's product ID and source URL. Similar titles or images do not prove that two listings are the same SKU or supplier. Verify the variant, pack size, destination, currency and offer eligibility before comparing. A displayed search price is not a verified checkout total or landed cost; do not treat missing shipping, tax or stock data as zero.

For the video tool, current caption-result rates are YouTube: $4 per 1,000 and TikTok: $1.50 per 1,000. Optional AI transcription is $0.006 per started audio minute at this plan tier; check the selected Actor's billing conditions before enabling it.

Items excluded from a result fee do not make the entire run free. All four underlying Actors currently list an Actor Start fee of $0.00005 per GB of memory, with a one-event minimum, and other applicable charges may apply. TikTok Transcript lists a scheduled startup-rate change to $0.0011 per GB from 4 November 2026, 03:53:50 UTC; check the live Pricing tab before recurring use.

Free-plan credit can cover eligible charges only while credit remains. Check the actual run's usage before increasing volume. A timed-out Dify call can still be running on Apify: keep its run ID and use Get Run Results, rather than starting a duplicate run just to retrieve the same job.

Limits worth knowing

TikTok Shop needs links or product IDs. It doesn't search by keyword, and it covers the US store only.
AliExpress returns search-result data, not product-page details or store names.
The plugin only calls api.apify.com. It never logs in to TikTok, AliExpress or YouTube.

Source: github.com/LMSlay/dify-plugin-tubetext. Issues and ideas are welcome there.

How to connect Apify to Claude (MCP) and give it YouTube transcripts in 5 minutes

LMSlay — Tue, 13 Oct 2026 13:56:35 +0000

Disclosure: I build TubeText, a set of pay-per-result Apify Actors. The example below uses one of them. The setup works the same for any Actor in Apify Store.

Claude can't watch a YouTube video. If you paste a link, it will either refuse or guess from the title. With the Apify MCP server connected, Claude can fetch the actual transcript and work from that. Caption-based transcription costs a fraction of a cent per video on the Free plan. Videos without captions can instead trigger per-minute AI transcription; check the Actor's current Pricing tab and input settings. Claude access is separate from Apify usage, and you don't write any code.

Here is the setup, plus what I checked myself.

What you need

Claude (Desktop or claude.ai) with custom connectors available on your plan
A free Apify account. The free plan includes $5 of monthly usage, enough for about 1,200 transcripts with captions.

Step 1: build your server URL

The Apify MCP server lives at https://mcp.apify.com. With no parameters, it loads a general tool set: Actor search, docs search, a web browser Actor and a few helpers. Claude then has to search Apify Store for a suitable tool every time.

For a specific job, give Claude exactly the tool it needs with the tools parameter:

https://mcp.apify.com?tools=tubetext/youtube-transcript-fast

You can list several Actors separated by commas. The MCP configurator builds the URL for you if you'd rather click than type.

Why bother? When I asked the server's own search-actors tool for "youtube transcript", it returned ten different Actors with different inputs and prices. With the tool pinned in the URL, Claude skips that step and calls the same Actor every time, with the same input format.

Step 2: add it to Claude as a custom connector

Per Apify's Claude Desktop docs:

In Claude, open Settings → Connectors.
Click Add → Add custom connector.
Name it Apify and paste your URL from step 1 as the Remote MCP server URL.
Click Continue, keep the detected settings, then Add.
A browser window opens. Sign in to Apify and approve access.

That last step is OAuth, so you never paste an API token into Claude. I checked that the server enforces this: calling the URL above without signing in returns 401 with an OAuth challenge. Remote connectors run on Anthropic's side, so the same connector also works on claude.ai.

Step 3: ask Claude something

Start a new chat and try:

Get the transcript of https://www.youtube.com/watch?v=jNQXAC9IVRw and summarize it in one sentence.

Behind the scenes Claude calls the Actor, which returns a JSON row per video. Here is the real output for that link (YouTube's first ever video), shortened:

{
  "title": "Me at the zoo",
  "channelName": "jawed",
  "durationSeconds": 19,
  "language": "en",
  "source": "captions",
  "wordCount": 39,
  "timestampedText": "[00:01] All right, so here we are, in front of the elephants\n[00:05] the cool thing about these guys is that they have really...\n[00:07] really really long trunks ...",
  "status": "ok"
}

The run took a few seconds and was billed one transcript ($0.004 on the free plan).

Other prompts that work well with this one tool:

"Pull the transcripts of the last 10 videos on @channel and list the topics they keep coming back to."
"Here are 5 product review videos. Make a table of the pros and cons each reviewer mentions, with timestamps."
"Turn this talk into a blog post outline and quote the three strongest lines."

Things worth knowing

Videos without captions: when enabled, Whisper AI fallback is billed per started minute only when a transcript is delivered. Set aiFallback to false for captions-only requests. maxAiMinutesPerVideo sets the maximum eligible video length: longer videos are skipped, not partially transcribed. Check your actual input settings before running.
Long jobs: the MCP call-actor tool waits up to 45 seconds. For a whole channel, Claude gets a run ID back and can fetch the results with get-dataset-items once the run finishes.
Spend control: you can pass maxTotalChargeUsd as a run option, so a single run can't go over a budget you set.
Pick tools on purpose: for production use, Apify recommends listing tools explicitly instead of relying on the defaults, so behavior doesn't change when the defaults do.

Same pattern, other data

Swap the Actor name in the URL and Claude gets a different capability. TikTok or Instagram transcripts, Amazon products and Google Flights prices all work the same way. The full list of TubeText tools is on our Apify profile, and Apify Store has thousands more.

If something breaks, open an issue on the Actor's page. I read every one.

Instagram Reels to text in bulk (no login): transcripts, hooks and on-screen text

LMSlay — Fri, 09 Oct 2026 06:47:44 +0000

Disclosure: I build the Apify Actor used in this post (TubeText Labs).

Instagram doesn't give you transcripts for Reels, and copying captions misses what people actually say. If you research hooks, repurpose content, or feed creators' videos into an LLM, you want the spoken words as text – for many reels at once. Here's a way to do it without logging in.

A creator's latest reels → text

curl -X POST "https://api.apify.com/v2/acts/tubetext~instagram-reels-transcript/run-sync-get-dataset-items?timeout=300" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"urls": ["@natgeo"], "maxReelsPerProfile": 10}'

You can mix @usernames, profile links and single reel links in the same list.

Each row has the transcript (plain, timestamped, or SRT), the opening hook line, the caption, plays, likes and posting time. The speech is transcribed with Whisper, so it handles 90+ languages.

Things that save you money

Music-only reels and songs have no transcript fee. A reel that's only a song comes back as no_speech or lyrics (with the song text). If optional on-screen text is enabled and text is found, that separate event can still be billed; any Actor Start charge is separate too.
Only new reels. Turn on Only new reels and schedule the run daily: each run transcribes just what the creator posted since last time.
Optional on-screen text. Many reels put the message in captions on screen, not in the audio. includeOnScreenText reads those overlays with a vision model (+$0.002 per reel, only when text is found) – useful for recipe and listicle reels with no speech at all.

Speed and cost

About 15 reels per minute with default settings. On the Free plan, a delivered reel transcript costs $0.006 including its first 3 minutes of audio; longer audio costs $0.003 per extra started minute. Private, deleted and failed reels have no transcript-result fee. Optional on-screen-text events and any Actor Start charge are separate, so no transcript fee does not necessarily mean a zero-cost run. See the current Pricing tab before running a batch.

Ideas

Build a swipe file of the opening hooks of the 50 latest reels in your niche.
Turn a coach's reels into a searchable knowledge base for an AI assistant.
Track competitors daily with Only new reels and send new transcripts to Slack.

Actor: https://apify.com/tubetext/instagram-reels-transcript

Google Hotels API: booking-site prices and a 90-day price calendar

LMSlay — Fri, 09 Oct 2026 03:51:29 +0000

Disclosure: I build the Apify Actor used in this post (TubeText Labs).

Need Google Hotels prices as JSON or CSV for a travel dashboard or a competitor-rate comparison? This tutorial returns the booking-site offers Google shows for your selected dates, then builds a price calendar for a hotel. It reads Google Hotels; it is not Google's official API or a booking service. Availability and rates can change before you book.

1. Get hotel prices by booking site for a city and fixed dates

curl -X POST "https://api.apify.com/v2/acts/tubetext~google-hotels-scraper/run-sync-get-dataset-items?timeout=300" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"locations": ["Lisbon"], "checkInDate": "2026-11-20", "checkOutDate": "2026-11-22",
       "currency": "USD", "maxHotelsPerLocation": 20, "includeBookingOffers": true}'

Each hotel comes back with its rating, star class, location and the lowest price. With includeBookingOffers it also gets a bookingOffers list – vendor, nightly and total price, room types, whether it's the official site and whether it's an ad – cheapest first, plus cheapestVendor. The original Lisbon example had 9–28 booking sites per hotel. That is a historical sample, not a minimum vendor count or a guarantee of coverage for another search.

2. When is this hotel cheapest? A price calendar

Take any hotel's googleHotelsUrl from step 1 and ask for a calendar:

{
  "calendarHotelUrls": ["https://www.google.com/travel/hotels/entity/…"],
  "checkInDate": "2026-11-20",
  "calendarDays": 30,
  "calendarNights": 1,
  "currency": "USD"
}

You get one row per check-in date with lowestPricePerNight, lowestVendor and the vendor prices returned for that date. Sort the rows by checkIn before charting them. Dates with no rates come back as no_rates and do not incur the calendar-date event charge; run-start billing is separate.

3. Track the same event-weekend stay across collection dates

“How much did this weekend's hotel price change since yesterday?” needs two observations of the same stay. Keep check-in and check-out fixed; change only when you collect the quote. A calendar answers a different question: which check-in date is cheaper? For example, SerpApi's calendar documentation describes prices for one-night stays beginning on different dates. Those dates are stay dates, not a history of what yesterday's search returned.

Build the comparison before calculating a change

Save the fixed-date input from step 1 with explicit checkInDate, checkOutDate, adults and currency, plus includeBookingOffers: true. Keep the destination and search settings unchanged. Archive each returned dataset separately, with a collection timestamp and run reference that you add. The documented output does not supply a historical observation series or backfill earlier quotes.
Flatten bookingOffers into one row per returned offer. Carry the parent hotel's id, name, googleHotelsUrl, checkIn, checkOut, nights, adults and currency; retain the offer's vendor, roomTypes, pricePerNight and totalPrice. Keep raw values too. These fields are documented in the current output schema, but they are optional, so missing data must remain missing.
Match hotel identity, stay, occupancy, currency, booking source, room and rate conditions. Use the returned id and URL as matching evidence, not a promise of a permanent identifier. Do not join by hotel name alone or compare whichever vendor happens to be cheapest each day. roomTypes text does not establish that a specific room/rate plan stayed identical. Record room count, children, meal plan and cancellation/payment terms in analyst-maintained columns after checking the source. The input schema documents adults, not controls for all those dimensions.
Check the tax basis for the specific offer. Preserve the hotel-row priceIncludesTaxesAndFees value, including null; do not automatically copy it to every vendor offer. If offer-level inclusion, occupancy or room/terms cannot be verified, label the pair not comparable / needs review, leave the change blank and retain the observations.

Worked comparison: two fictional observations

Everything below is illustrative, not a test result or a real hotel quote. Assume an analyst has independently verified the following matching details for both observations. These are the analyst's comparison keys and review notes, not additional Actor output fields.

Fixed comparison key	Value for both observations
Hotel	Example Riverside Hotel, Lisbon; same property independently checked
Stay	Check-in 2026-11-20, check-out 2026-11-22; 2 nights
Occupancy	1 room, 2 adults, no children; independently checked
Room and rate terms	Standard double, breakfast excluded, non-refundable, pay now; independently checked
Booking source	Example Travel, the same fictional vendor
Currency and offer tax basis	USD; both displayed offers independently confirmed to include taxes and mandatory fees

Use an analyst-assigned label such as event_stay_A for this exact combination. It is not a hotel ID returned by the API. The unknown breakdown amounts below remain unknown even though inclusion in these fictional totals has been confirmed.

Collection time (UTC)	Comparison label	Nightly quote (USD)	Stay total (USD)	Tax amount / fee amount	Review
2026-10-21 09:00	event_stay_A	180	360	unknown / unknown	Comparable
2026-10-22 09:00	event_stay_A	198	396	unknown / unknown	Comparable

After that review, the two-night stay increased by 396 - 360 = USD 36, or (396 - 360) / 360 × 100 = 10%. The nightly change is USD 18, also 10%; do not compare one observation's nightly price with the other's stay total. Use the returned stay total when available rather than replacing it with a rounded nightly rate multiplied by nights. A zero or missing baseline has no valid percentage change.

For a real event-weekend shortlist, this tells you which verified offer to recheck, not whether to book. If the second observation has no matching offer, record not observed rather than zero, unchanged or sold out. If the room, vendor or terms change, start a separate comparison. You can build a history only from observations you retain; returned coverage and a later bookable price are not guaranteed.

Things to know

Prices are what Google shows US visitors, taxes and fees included (priceIncludesTaxesAndFees tells you per row). Visitors from other countries can see different rates.
Google returns at most about 420 hotels per search. For more, split a city into neighbourhoods.
For a comparable price history, keep the stay dates, guest count and currency fixed, save each run's observation time, and compare pricePerNight for the same hotel id. A changing default stay date is a different search.
Treat nightly prices and stay totals as different measures. Keep the dates, room details and tax/fee flag alongside the price; the cheapest headline offer is not proof that cancellation rules or room conditions match.
To export without code, run the Actor in Apify and use the dataset's Export option for CSV or Excel. Overlapping destination searches may contain the same hotel, so deduplicate your combined table by hotel and stay.

Cost

Pricing checked on 23 October 2026: at the Apify Free-plan event rates, $3 per 1,000 hotels with a price, an additional $2 per 1,000 hotels whose booking-site breakdown is delivered, and $3 per 1,000 priced calendar dates. Higher plans have their own rates.

The separate Actor Start event is $0.00005 per event, with one event per GB of Actor memory and a minimum of one. No-rate dates and failed searches have no corresponding result-event charge, but that does not make the whole run free.

For example, 20 priced hotels with 20 delivered booking-site breakdowns cost $0.06 + $0.04 = $0.10 in result events. A 30-day calendar for 5 hotels has at most 150 priced dates, or $0.45 in calendar events. Add the start event(s) in either case. These are event-charge examples, not measured bills or a guarantee of returned rows. Check the current pricing and the run's charge summary.

Actor: https://apify.com/tubetext/google-hotels-scraper

How to get TikTok Shop product data (price, sales, stock per SKU) as JSON in 2026

LMSlay — Fri, 09 Oct 2026 03:41:28 +0000

Disclosure: I build the Apify Actor used in this post (TubeText Labs).

TikTok Shop has no public API for product data. Most "TikTok Shop spy" dashboards build on the same public product-page numbers: the price, the "sold" count and the shop stats. If you only need that data for your own research, a dashboard subscription is overkill. Here's how to get it as JSON.

What you can get from a public TikTok Shop product page

price, original price and discount
items sold (TikTok's "sold since listing" counter)
rating and review count
every variant (SKU) with its own price and stock
specifications, shipping, delivery estimate
the shop's stats: rating, followers, products, total sold, number of videos

One API call

curl -X POST "https://api.apify.com/v2/acts/tubetext~tiktok-shop-product-scraper/run-sync-get-dataset-items?timeout=300" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"urls": ["https://www.tiktok.com/shop/pdp/1729527313880355335"]}'

You can also pass a store page (you get its first 20 products) or a category page (a sample of up to 100 products).

Real output (shortened)

{
  "title": "Goli Ashwagandha & Vitamin D Gummy - Mixed Berry…",
  "price": 19.47,
  "originalPrice": 24.7,
  "soldCount": 1304190,
  "rating": 4.5,
  "reviewCount": 94525,
  "skus": [{"options": "Size: 1 Bottle", "price": 19.47, "stock": 336485}],
  "shopFollowers": 601031,
  "shopSoldCount": 5777630
}

Turning it into "daily sales"

TikTok only shows a running total, so daily sales are the difference between two snapshots:

# yesterday.json and today.json are two runs over the same product URLs
import json
y = {p["productId"]: p for p in json.load(open("yesterday.json"))}
for p in json.load(open("today.json")):
    if p["productId"] in y:
        print(p["title"][:50], p["soldCount"] - y[p["productId"]]["soldCount"], "sold in 24h")

Schedule the run daily on Apify (or from n8n/Make), and you have a small competitor tracker. Per-SKU stock tells you which variant is actually moving.

Limits (so you don't waste time)

US TikTok Shop only for now.
No keyword search yet: use product, store or category links.
Store pages return their first 20 products.
"Sold" is TikTok's displayed counter, not audited sales.

Pricing is $4 per 1,000 products with full details ($1.50 per 1,000 if you only need listing cards), and failures are free.

Actor: https://apify.com/tubetext/tiktok-shop-product-scraper