DEV Community: Gio Rich

Manufacturer, trader or a badminton shop? Scoring the suppliers behind an Alibaba search with Python

Gio Rich — Sun, 01 Nov 2026 18:14:58 +0000

Search Alibaba for a product and you get 48 product cards per page. What you actually want to know is who is behind them: is it a factory or a trading company, has a third party inspected it, does it answer messages, does it sell much online, and is "yoga mat" really its business or just one listing in a sports-goods shop?

All of that is on the search cards already, spread over a dozen badges and tooltips. I wrote Alibaba Supplier Search Scraper to collapse a keyword's results into one row per supplier with those signals as plain fields. This post shows how to call it from Python and Node, what a row looks like, and a small scoring script that re-ranks suppliers by trust instead of by search position.

How it works

Alibaba's search page loads its results from a JSON endpoint. The actor calls that endpoint over plain HTTPS (no browser, no login), reads up to 20 pages per keyword (48 products each), groups the products by supplier and keeps the supplier card: business type, years on Alibaba, Verified / Verified PRO / Gold / Trade Assurance, inspection company, store rating with its three sub-scores, response rate, online transactions, Alibaba's online revenue band, staff, factory size, main products and export markets. Next to that it adds what the supplier sells for your keyword: how many matching products, how many of those are ads, price range, lowest MOQ, total sold and up to 5 sample products.

Filters (Trade Assurance only, manufacturers only, minimum years / rating / reviews / staff, country, price, MOQ) are applied before saving, and suppliers dropped by a filter are never charged. No contact names, phones or emails are collected; each row has contactSupplierUrl, Alibaba's own inquiry form.

Calling it from Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("rel8ble/alibaba-supplier-search-scraper").call(run_input={
    "searchTerms": ["yoga mat", "yoga block"],
    "maxSuppliersPerSearch": 50,
    "tradeAssuranceOnly": True,
    # "manufacturersOnly": True,
    # "minYearsOnAlibaba": 3,
    # "minRating": "4.5",
})

for s in client.dataset(run["defaultDatasetId"]).iterate_items():
    if "supplierId" not in s:
        continue
    print(s["rank"], s["supplierName"], "|", "/".join(s["businessType"]),
          "|", s["verifiedBy"], "| rating", s["rating"], "| MOQ", s["lowestMoq"])

The same from Node:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('rel8ble/alibaba-supplier-search-scraper').call({
    searchTerms: ['yoga mat'],
    manufacturersOnly: true,
    tradeAssuranceOnly: true,
    maxSuppliersPerSearch: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((s) => s.supplierId).map((s) => `${s.supplierName} (${s.yearsOnAlibaba} yrs)`));

What a row looks like

The top yoga mat result from a run on 30 Oct 2026, trimmed to the fields used below:

{
  "searchTerm": "yoga mat",
  "rank": 1,
  "supplierName": "Fuqing Shengde Ruibo Technology Co., Ltd.",
  "country": "China",
  "businessType": ["Trading Company"],
  "isManufacturer": false,
  "yearsOnAlibaba": 3,
  "goldSupplier": true,
  "tradeAssurance": true,
  "verifiedBy": "SGS",
  "rating": 4.4,
  "reviewCount": 14,
  "responseRatePct": 89.3,
  "onlineRevenueUsd": 220000,
  "employees": 10,
  "factorySizeSqm": 160,
  "mainProducts": "Yoga Mat, Exercise Mat, Yoga Block, Yoga Roller, Fitness Set",
  "exportCountries": [],
  "matchingProducts": 4,
  "sponsoredListings": 3,
  "productPriceMin": 2.8,
  "productPriceMax": 9.99,
  "lowestMoq": 100,
  "soldCountTotal": 3786
}

These are the first five suppliers from that run:

rank	supplier	type	years	inspected by	rating (reviews)	response	revenue band	listings (ads)	price	lowest MOQ
1	Fuqing Shengde Ruibo Technology	Trading	3	SGS	4.4 (14)	89.3%	$220K+	4 (3)	$2.80-9.99	100
2	Xiamen Kejinqu Toy Products	Trading	1	-	4.6 (22)	98.8%	$50K+	2 (2)	$1.80-27.80	1
3	Wenzhou Qiangfeng Technology	Manufacturer + Trading	5	-	4.7 (11)	98.8%	$150K+	7 (1)	$3.99-14.60	2
4	Hefei Avant Fitness	Trading	2	Intertek	4.8 (29)	99.1%	$110K+	3 (2)	$0.15-10.60	1
5	Tianjin Xiqing District Baoya Trading Firm	Trading	1	-	5.0 (1)	83.7%	$1K+	3 (0)	$4.72-6.45	20

A few things stand out. All five are Gold Suppliers with Trade Assurance, so those two badges do not separate anyone here. Only one of the five lists itself as a manufacturer. The two that a third party inspected (SGS, Intertek) are both trading companies. Eight of the 19 matching listings are ads, and four of the five suppliers reached page 1 at least partly through ads. And the #5 result has a perfect 5.0 rating from a single review, a $1K+ revenue band and main products "badminton, football, clothes".

A trust score instead of search position

Search position mixes relevance, ads and Alibaba's own ranking. For a first shortlist I would rather sort by signals I can explain. A deliberately simple 0-10 score:

def trust_score(s):
    keyword = s["searchTerm"].lower()
    points = 0
    points += 2 if s.get("verifiedBy") else 0                      # inspected by SGS, TUV, Intertek ...
    points += 2 if s.get("isManufacturer") else 0
    points += 1 if (s.get("yearsOnAlibaba") or 0) >= 3 else 0
    points += 1 if (s.get("rating") or 0) >= 4.5 and (s.get("reviewCount") or 0) >= 10 else 0
    points += 1 if (s.get("responseRatePct") or 0) >= 95 else 0
    points += 1 if (s.get("onlineRevenueUsd") or 0) >= 100_000 else 0
    points += 1 if keyword in (s.get("mainProducts") or "").lower() else 0
    points += 1 if s.get("exportCountries") else 0
    return points


def red_flags(s):
    keyword = s["searchTerm"].lower()
    flags = []
    if (s.get("reviewCount") or 0) < 5:
        flags.append(f"only {s.get('reviewCount') or 0} reviews")
    if keyword not in (s.get("mainProducts") or "").lower():
        flags.append("keyword not in main products")
    if s.get("onlineRevenueUsd") is not None and s["onlineRevenueUsd"] < 10_000:
        flags.append(f"revenue band ${s['onlineRevenueUsd']:,}+")
    if s.get("matchingProducts") and s.get("sponsoredListings") == s.get("matchingProducts"):
        flags.append("every listing is an ad")
    return flags

Run over the five rows above, it reorders them like this:

score  rank  supplier                                   type                         flags
    8     3  Wenzhou Qiangfeng Technology Co., Ltd.     Manufacturer/Trading Company -
    7     4  Hefei Avant Fitness Co., Ltd.              Trading Company              -
    5     1  Fuqing Shengde Ruibo Technology Co., Ltd.  Trading Company              -
    3     2  Xiamen Kejinqu Toy Products Co., Ltd.      Trading Company              every listing is an ad
    0     5  Tianjin Xiqing District Baoya Trading Firm Trading Company              only 1 reviews; keyword not in main products; revenue band $1,000+

The #3 search result comes out on top: a manufacturer with 5 years on Alibaba, 98.8% response, a $150K+ revenue band, yoga mats as a main product, 7 matching listings with only one ad, and 8 export markets including the United States. Hefei Avant is a trading company, but Intertek-inspected, 4.8 from 29 reviews, 9,406 sold across its listings and shipping to 14 countries. The #1 result drops to third mostly because of its 89.3% response rate and no listed export markets.

The weights are mine; change them to match what you care about (a dropshipper cares about MOQ 1, a brand owner about factories and certificates). The point is that every input is a field in the row, so the ranking is explainable.

Going further

Pre-filter in the run instead of in Python: manufacturersOnly, verifiedSuppliersOnly, minYearsOnAlibaba, minRating, minReviews, maxMoq. Filtered suppliers are free.
Many keywords at once: with dedupeAcrossSearches on, a supplier that sells "yoga mat" and "yoga block" is one row, and matchedSearchTerms lists both.
Then go deeper on the shortlist: pass supplierUrl to my Alibaba Supplier Store Scraper for the full catalog, or sampleProducts[].url to the Alibaba Product Details Scraper for price ladders and lead times.

Pricing and limits

$0.60 per 1,000 suppliers, no start fee: a 50-supplier shortlist costs $0.03. Search pages, filtered-out suppliers, duplicates and failed requests are not charged. A 50-supplier cloud run took 35 seconds including start-up.

Limits: up to 20 search pages per keyword (about 960 products, usually 400-600 suppliers). This is search-card data, so address and detailed capabilities are on the supplier's own pages. Fill rates on 50 "yoga mat" suppliers: name, country, years, response rate, main products, price and MOQ on every row; rating 96%, revenue band 98%, verified 62%, export markets 52%, staff 46%. Alibaba matches keywords loosely, so check sampleProducts when precision matters.

Store page: https://apify.com/rel8ble/alibaba-supplier-search-scraper

Need a custom scraper or a ready dataset? Hire me on Fiverr: https://www.fiverr.com/rel8ble

This article was drafted with AI and published by me.

DHgate vs Alibaba prices, compared programmatically (Python, real numbers)

Gio Rich — Sat, 31 Oct 2026 17:15:10 +0000

"Should I buy this on DHgate or Alibaba?" usually gets answered with vibes: DHgate is for small orders, Alibaba is for bulk. That's roughly right, but it doesn't tell you where the line is for your product. The line is a number, and you can compute it.

This post runs the same four keywords through DHgate Scraper and Alibaba Scraper, normalises the units, and compares three things per keyword: unit price at one piece, unit price at volume, and the cash a first order needs. Alibaba data: 75 listings per keyword from a run on 24 Sep 2026. DHgate data: 40 listings per keyword from a run on 27 Oct 2026. Different dates, so treat small gaps as noise and big gaps as signal.

The result

Only listings sold per piece/pair/set/unit are counted, so a $2 "per meter" LED strip isn't compared with a $14 "per piece" one. Medians in USD, exactly as the script below prints them:

Keyword	DHgate price at 1 piece	DHgate best tier	Alibaba price at MOQ	Alibaba price at 1,000	DHgate median MOQ	Alibaba median MOQ	First order, DHgate	First order, Alibaba
yoga mat	$38.26	$18.71	$11.26	$9.72	1	50	$38.26	$377.00
bluetooth earbuds	$17.07	$11.41	$7.16	$6.30	1	10	$23.95	$87.40
led strip lights (per piece)	$14.43	$9.05	$2.30	$2.20	1	20	$14.43	$138.75

Reading it:

Per unit, Alibaba is cheaper: 1.6-4x below DHgate's best quantity tier and 2.4-6x below its one-piece price, before shipping.
Per first order, DHgate is 3.5-10x cheaper, because most listings have an MOQ of one (all 40 yoga mats, 33 of 40 earbuds, 25 of 40 LED strips).
The crossover is simple arithmetic: for yoga mats, 10 units on DHgate at $38.26 ≈ $383, about the same cash as the median Alibaba first order of 50 units ($377). If you need more than about 10 mats, Alibaba wins; for a 1-3 unit quality test, DHgate wins. For earbuds the crossover is about 5 units ($87.40 / $17.07).

Shipping changes this at the margin: about half the DHgate listings ship free (19 of 40 yoga mats, 20 of 40 earbuds), while Alibaba search prices never include shipping.

The keyword trap

The fourth keyword, "custom tote bags", came out as a median lowest price of $0.45 per bag on Alibaba vs $46.64 on DHgate. That's not a price gap, it's a different product: Alibaba returns blank printable promo totes at MOQ 100, DHgate returns finished fashion tote handbags at MOQ 1. Always look at the titles before trusting a comparison; matching on keyword alone compares whatever each marketplace ranks for that word.

A second trap: DHgate's best sellers for "bluetooth earbuds" (259 and 258 sold) were lookalikes of a big brand's earbuds. Cheap, popular, and a trademark problem if you resell them. Alibaba's cheapest verified earbud listings at MOQ 2-5 were the suppliers' own brands at $3-5.

The script

pip install apify-client

from apify_client import ApifyClient
from statistics import median
import re

client = ApifyClient("<YOUR_APIFY_TOKEN>")
KEYWORDS = ["yoga mat", "bluetooth earbuds", "led strip lights"]
PER_PIECE = re.compile(r"piece|pcs|pair|set|unit", re.I)

def run(actor, run_input):
    r = client.actor(actor).call(run_input=run_input)
    return list(client.dataset(r["defaultDatasetId"]).iterate_items())

dh = run("rel8ble/dhgate-scraper", {"searchTerms": KEYWORDS, "maxResultsPerSearch": 60})
ali = run("rel8ble/alibaba-product-search-scraper",
          {"searchTerms": KEYWORDS, "maxResultsPerSearch": 100, "includeAds": False})

def ali_price_at(p, qty):
    """Unit price at a quantity from Alibaba's price ladder."""
    tiers = [t for t in (p.get("priceTiers") or []) if t["minQuantity"] <= qty]
    return tiers[-1]["price"] if tiers else None

def m(values):
    values = [v for v in values if v]
    return round(median(values), 2) if values else None

print(f"{'keyword':<20}{'DH 1pc':>8}{'DH best':>9}{'ALI moq':>9}{'ALI 1k':>8}{'DH 1st':>8}{'ALI 1st':>9}{'crossover':>11}")
for kw in KEYWORDS:
    d = [p for p in dh if p["searchTerm"] == kw and PER_PIECE.search(p.get("moqUnit") or "")]
    a = [p for p in ali if p["searchTerm"] == kw and PER_PIECE.search(p.get("moqUnit") or "")]
    dh_1pc = m(p["priceMax"] for p in d)
    dh_best = m(p["priceMin"] for p in d)
    ali_moq = m(ali_price_at(p, p["moq"] or 1) for p in a)
    ali_1k = m(ali_price_at(p, 1000) for p in a)
    dh_first = m((p["moq"] or 1) * p["priceMax"] for p in d if p["priceMax"])
    ali_first = m((p["moq"] or 1) * (ali_price_at(p, p["moq"] or 1) or 0) for p in a)
    cross = round(ali_first / dh_1pc) if ali_first and dh_1pc else None
    print(f"{kw:<20}{dh_1pc:>8}{dh_best:>9}{ali_moq:>9}{ali_1k:>8}{dh_first:>8}{ali_first:>9}{cross:>11}")

crossover is the order size (in units) where buying on DHgate at the one-piece price costs as much as the median Alibaba first order. Below it, test on DHgate; above it, source on Alibaba.

The run above (180 DHgate + 300 Alibaba products) costs about $0.48 in actor fees. Both actors work over plain HTTP, so it finishes in well under a minute.

Going further

Filter before comparing. On Alibaba, verifiedSuppliersOnly: true and maxMoq run on Alibaba's side; on DHgate, minRating, minSold and freeShippingOnly do the same. Comparing "verified Alibaba factories" with "DHgate sellers with 50+ sales and free shipping" is fairer than comparing everything.
Track it. Schedule both actors weekly and store the medians; a widening gap is often a promotion on one side.
Add a third market. Global Sources and AliExpress have the same shape of output, so the same script extends to four marketplaces.
No code? Both actors run from a form on their Store page and export CSV or Excel; Make, n8n and Zapier have Apify modules that run an actor and return its dataset.

Store pages:

Need a custom scraper or a ready dataset? Hire me on Fiverr: https://www.fiverr.com/rel8ble

This article was drafted with AI and published by me.

Building agency lead lists from Sortlist with Python

Gio Rich — Fri, 30 Oct 2026 17:21:56 +0000

If you sell to agencies (white-label services, SaaS for marketers, partnerships), you need a list of agencies with their size, budget range and website. Clutch has that list but sits behind Cloudflare. Sortlist, a European agency marketplace, has the same kind of directory for marketing, design and IT agencies in most countries, and it is open.

I'm an 18-year-old engineering student, and I built Sortlist Scraper to turn a directory like "advertising agencies in the United States" into one clean JSON row per agency, over plain HTTP. This post covers how it works, calling it from Python and Node, what a row looks like, and a small project: a partnership shortlist.

How it works

Sortlist is a Next.js site, so every page carries its data as JSON in a __NEXT_DATA__ script tag. A directory page (/<service>/<location>) lists the agencies with their website, team size, review count, address, languages, registration number, budget and services. Page 1 shows 20 agencies and later pages show 100, so a directory of 3,600 agencies takes about 38 requests.

With agency pages switched on, it opens each /agency/<slug> page and adds the founding year, revenue, every office with coordinates, social profiles, per-service budgets, awards and reviews. Ratings are stored from 0 to 1 and returned on a 5-point scale. Filters (must have a website, minimum reviews / rating / team size / budget) run before anything is charged.

A lesson from the first cloud run: some agencies have an AI review summary stored as an object, and Apify's dataset schema check rejected those rows. The actor now flattens it into text plus a reviewKeyPoints list, and I validate a real local dataset against the schema before every push.

Calling it from Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("rel8ble/sortlist-scraper").call(run_input={
    "startUrls": [
        "https://www.sortlist.com/digital-marketing/united-kingdom-gb",
        "https://www.sortlist.fr/seo/paris-ile-de-france-fr",
    ],
    "maxResultsPerDirectory": 200,
    "requireWebsite": True,
    "minTeamSize": 10,
})

for a in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(a["name"][:35], "|", a["website"], "|", a["teamSize"], "|", a["city"], "|", a["founded"])

The same from Node:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('rel8ble/sortlist-scraper').call({
    startUrls: ['https://www.sortlist.com/advertising/united-states-us'],
    maxResultsPerDirectory: 0, // the whole directory
    scrapeDetails: false, // directory data only: 100 agencies per request
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'advertising agencies');

What a row looks like

From a real run, trimmed:

{
    "name": "Goliaence",
    "website": "https://goliaence.com",
    "tagline": "Make them notice. Digital marketing, creative and applied AI.",
    "address": "1 Chisholm Trail Road, Round Rock, TX, USA",
    "countryCode": "US",
    "latitude": 30.5140931,
    "longitude": -97.6890449,
    "teamSize": 5,
    "founded": 2025,
    "budgetMin": 1000,
    "budgetMax": 1000000,
    "services": ["Advertising", "Online Advertising"],
    "industries": ["Industrial Goods & Services", "Construction"],
    "languages": ["en"],
    "socialLinks": ["https://www.linkedin.com/company/goliaence/"],
    "projectsCount": 7,
    "verified": true,
    "worksRemotely": true,
    "url": "https://www.sortlist.com/agency/goliaence",
    "directory": "Top Advertising Agencies in the United States",
    "position": 2
}

In a 451-agency test (website and 1-review filters on), every row had a website, address, coordinates, team size and rating; 97% had a founding year and social links, 87% a budget range and 53% revenue.

Project: a partnership shortlist

Say you offer white-label SEO. The best partners are established agencies that sell digital marketing but do not list SEO, with a team big enough to resell.

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

def fit(a):
    services = {s.lower() for s in a["services"]}
    if any("seo" in s for s in services):
        return 0                                   # already does SEO
    s = 0
    s += 2 if (a["teamSize"] or 0) >= 10 else 0
    s += 2 if a["founded"] and a["founded"] <= 2018 else 0
    s += 1 if (a["reviewCount"] or 0) >= 5 else 0
    s += 1 if a["budgetMin"] and a["budgetMin"] >= 5000 else 0
    return s

shortlist = sorted(rows, key=fit, reverse=True)[:20]
for a in shortlist:
    print(f"{a['name'][:30]:30} {fit(a)}  {a['teamSize']:>4}  {a['city'] or '':15} {a['website']}")

The socialLinks column usually includes the agency's LinkedIn page, which is where the outreach starts.

Pricing and limits

$0.75 per 1,000 agencies, no start fee, same price with or without agency pages. Filtered agencies, duplicates, dead directories and failed requests are never charged. No e-mails or phone numbers (Sortlist routes contact through its own briefs; pair it with a website contact extractor), revenue and awards only when the agency publishes them, results in Sortlist's own order. Reviewer names are personal data, so treat them accordingly.

Store page: https://apify.com/rel8ble/sortlist-scraper

This article was drafted with AI and published by me.

How to export Yellow Pages business leads to CSV or Google Sheets (no code, API, n8n)

Gio Rich — Thu, 29 Oct 2026 09:13:03 +0000

"How do I export Yellow Pages to Excel?" is one of those questions with no good official answer. YellowPages.com has no export button and no public API, copy-paste breaks the address into one messy cell, and the site sits behind Cloudflare, which stops most quick scripts after a page or two.

I wrote an earlier post on the Python side (finding businesses without a website). This one is for the person who just wants the spreadsheet: three ways to get a clean CSV out of Yellow Pages Scraper, from zero code to a weekly automated feed into Google Sheets or a CRM. All numbers are from a real 256-row run on 24 Sep 2026 (plumbers and dentists in Austin and Denver, roofers and pizza in Charlotte).

What ends up in the spreadsheet

One row per business, with the columns a CRM import wants already split:

Column	What it is	Filled in our run
`name`, `categories`	Business name and YellowPages categories	256 of 256
`phone`, `phoneE164`	`(704) 251-9995` and `+17042519995` for dialers and SMS tools	256 of 256
`street`, `city`, `state`, `zip`	Address already split	all with a street address
`website`, `websiteDomain`	Full URL and bare domain for dedupe and enrichment	239 of 256
`rating`, `reviewCount`, `yearsInBusiness`	Reputation and age	when YellowPages shows them
`isClaimed`	Whether the owner claimed the listing	all rows
`email`, `services`, `paymentMethods`, `socialLinks`	Only with `includeDetails: true` (one extra page per business)	email on 12 of 21 detail rows

Real rows (roofing contractors, Charlotte NC):

name	phone	city	website	yearsInBusiness
Murr And Laney Inc	(980) 501-6075	Pineville, NC	murrlaney.com	61
JW Services Inc of NC	(980) 334-6603	Concord, NC	jwservicesofnc.com	22
D&W, Inc.	(704) 598-9316	Charlotte, NC	dwincnc.localsearch.com	43

A useful pattern from the same run: most local listings are unclaimed. 43 of 56 Austin dentists, 50 of 60 Austin plumbers and 51 of 60 Denver dentists had never claimed their YellowPages page. If you sell local SEO or listing management, that column is your prospect filter.

Way 1: the form (no code, 2 minutes)

Open the actor page and click Try for free.
Search terms: what you'd type in the YellowPages "Find" box, one per line (plumber, hvac contractor).
Locations: City, ST or a ZIP code, one per line (Austin, TX, Denver, CO, 10001). Every term runs in every location.
Max results: per term and location. 100 is a good start; a big metro tops out around 3,000 per search, so split by ZIP for full coverage.
Tick Include details only if you need emails. It opens one page per business, so it's slower; switch the proxy to RESIDENTIAL for those runs.
Click Start, then in Output download CSV or Excel.

Way 2: one HTTP call that returns a CSV

Apify has a "run and wait for the data" endpoint. This returns the CSV directly, which is handy in a shell script, Google Apps Script or anything that can make an HTTP request:

curl -X POST \
  "https://api.apify.com/v2/acts/rel8ble~yellowpages-scraper/run-sync-get-dataset-items?format=csv" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms":["plumber"],"locations":["Austin, TX"],"maxResults":100}' \
  -o austin_plumbers.csv

The sync endpoint waits up to 5 minutes, which is plenty for a few hundred listings without details. For bigger jobs, start the run, then fetch the dataset when it finishes:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("rel8ble/yellowpages-scraper").call(run_input={
    "searchTerms": ["plumber", "electrician", "roofing contractors"],
    "locations": ["Austin, TX", "Denver, CO", "Charlotte, NC"],
    "maxResults": 300,
})
csv_bytes = client.dataset(run["defaultDatasetId"]).get_items_as_bytes(item_format="csv")
open("leads.csv", "wb").write(csv_bytes)

Nine searches, up to 2,700 businesses, in one file.

Way 3: a weekly feed into Google Sheets or your CRM (n8n or Make)

For a territory list that stays fresh, schedule it:

n8n: install the Apify node (Settings > Community nodes, @apify/n8n-nodes-apify), then build Schedule Trigger (weekly) > Apify node: run actor rel8ble/yellowpages-scraper with the input JSON above and wait for it > Apify node: get the run's dataset items > Google Sheets "Append or update row" matched on ypid. Matching on ypid (YellowPages' own ID) keeps the sheet free of duplicates across runs.

Make: Apify "Run an Actor" (wait for finish on) > Apify "Get Dataset Items" > Google Sheets "Add a Row" or your CRM's "Create a Contact" module, mapping name, phoneE164, street, city, state, zip, website.

Zapier: trigger "Finished Actor Run" from the Apify app on a scheduled run, then "Fetch Dataset Items" into Sheets or HubSpot.

If you'd rather not wire anything, Apify's built-in Schedules run the actor weekly on their own, and you download the latest CSV when you need it.

Cleaning tips before you import

Drop sponsored cards. includeSponsored is off by default because YellowPages' ad cards are often from other cities.
Service-area businesses (isServiceAreaOnly: true) have no street address. Keep them for phone outreach, skip them for mailers.
Dedupe across overlapping cities on ypid or phoneE164, since a Pineville roofer shows up in a Charlotte search too.
Respect the rules of your channel. These are public business listings; cold calling and emailing still fall under TCPA, CAN-SPAM and your CRM's terms.

Cost

$1.50 per 1,000 businesses, pay per result; failed pages are never charged. The 256-row run above comes to about $0.38 at that price. The Apify free plan's monthly credit covers a few thousand leads.

Store page: https://apify.com/rel8ble/yellowpages-scraper
Python examples (MIT): https://github.com/Rel8ble/yellowpages-scraper-python

This article was drafted with AI and published by me.

How to find verified Alibaba suppliers with a low MOQ in bulk (and what a first order really costs)

Gio Rich — Wed, 28 Oct 2026 05:22:00 +0000

If you have ever sourced on Alibaba, you know the loop: search "yoga mat", open 40 tabs, check each one for the Verified badge, scroll to find the MOQ, squint at "US $7.50-$14.00", then try to remember which supplier was 3 years old and which was 18. Alibaba's own filters help, but they only show you one page at a time and you can't sort by "how much cash do I need to place a first order".

This post shows how to get that whole table at once: every listing for a keyword with its MOQ, price ladder, Verified / Trade Assurance status, supplier age, rating and the inspection company behind the badge. First the no-code way (a form and a CSV), then a short Python script. All numbers below come from a real run of Alibaba Scraper on 24 Sep 2026: 75 listings each for "bluetooth earbuds", "yoga mat", "custom tote bags" and "led strip lights".

What "verified" actually means on Alibaba

Three different badges get mixed up:

Verified supplier: the company was inspected on site by a third party. The scraper returns who did it in supplierVerifiedBy. In our run that was always one of SGS, TÜV Rheinland or Intertek.
Trade Assurance: Alibaba's payment protection on the order. Almost everyone has it (73 of 75 earbud listings, 75 of 75 yoga mats), so it doesn't separate anyone.
Gold supplier: a paid membership. All 300 listings in our run had it, so it says nothing either.

The badge that filters is Verified: 32 of 75 earbud listings, 60 of 75 yoga mats, 61 of 75 tote bags, 62 of 75 LED strips. Combine it with supplier age and rating and the list shrinks fast:

Keyword	Listings	Unique suppliers	Verified	Verified + MOQ ≤ 50	...and 5+ years, rating 4.5+
bluetooth earbuds	75	71	32	24	19
yoga mat	75	29	60	43	10
custom tote bags	75	48	61	13	3
led strip lights	75	56	62	46	29

Two things stand out. Yoga mat results come from only 29 suppliers for 75 listings, so the same factories repeat a lot (dedupe by supplier before you contact anyone). And custom tote bags are a high-MOQ category: the median MOQ was 100 pieces, so only 3 suppliers pass a strict low-MOQ filter.

The number Alibaba doesn't show: cash for a first order

A listing's MOQ times the unit price at that quantity is the smallest order you can place. For yoga mats, the median listing needs $377 for a first order (median MOQ 50 at the first price tier). For earbuds it's $99, for LED strips $115. That's the column I sort a shortlist by when testing a product.

Here are the cheapest first orders among verified, 5+ year, 4.5+ rated yoga mat suppliers in that run (one row per supplier):

Product (shortened)	MOQ	Unit price at MOQ	First order	Supplier	Years	Rating	Verified by
Eco Friendly Custom Logo Pilates Mat	2 pieces	$2.99	$5.98	Ningbo Boga Sports Goods	5	4.7	TÜV Rheinland
Arch Oval Curve Shaped Mat	1 piece	$14.00	$14.00	Nantong Vigor Sport Goods	8	4.9	TÜV Rheinland
LEECORK Organic Cork TPE Yoga Mat	12 pieces	$8.51	$102.12	Xi'an Leecork	18	4.9	SGS
Micogo Anti Slip Custom Logo Mat	12 pieces	$13.80	$165.60	Ningbo Winz Sports Goods	8	4.7	TÜV Rheinland
Natural Rubber PU Leather Mat	50 pieces	$10.00	$500.00	Dongguan Tongtianxia Rubber	19	4.8	SGS

That is five inspected, established factories you can order samples from for under $500 total, found in one run instead of an afternoon of tabs.

Option 1: no code (form in, spreadsheet out)

Open the actor page and click Try for free (new Apify accounts get a monthly free credit, which covers a few thousand products).
In Search terms, add your keywords, one per line: yoga mat, cork yoga mat, tpe yoga mat. Narrow variants matter because Alibaba serves about 960 products per keyword.
Under Filters, tick Verified suppliers only, set Max MOQ (for example 50) and optionally a Supplier country (CN, IN, VN, TR...).
Set Max results per search to 200 and click Start. 1,000 products take about 20 seconds.
In the Output tab, download CSV or Excel and open it in Google Sheets or Excel.

In the sheet, keep these columns and sort by minOrderValue (the first-order cash, computed for you in the current version): title, moq, moqUnit, priceAtMoq, minOrderValue, supplierName, supplierYears, supplierRating, supplierVerifiedBy, responseRate, contactSupplierUrl. The last one opens Alibaba's own contact form for that product, so outreach stays on Alibaba with Trade Assurance.

Option 2: Python, 25 lines

pip install apify-client

from apify_client import ApifyClient
import csv

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("rel8ble/alibaba-product-search-scraper").call(run_input={
    "searchTerms": ["yoga mat", "cork yoga mat", "tpe yoga mat"],
    "maxResultsPerSearch": 200,
    "verifiedSuppliersOnly": True,
    "maxMoq": 50,
    "includeAds": False,
})

best = {}  # one row per supplier: their cheapest first order
for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    tiers = p.get("priceTiers") or []
    unit = tiers[0]["price"] if tiers else p.get("priceMax")
    if not unit or not p.get("moq"):
        continue
    if (p.get("supplierYears") or 0) < 5 or (p.get("supplierRating") or 0) < 4.5:
        continue
    cash = round(p["moq"] * unit, 2)
    name = p["supplierName"]
    if name not in best or cash < best[name]["cash"]:
        best[name] = {"cash": cash, "moq": p["moqText"], "unit": unit, "years": p["supplierYears"],
                      "rating": p["supplierRating"], "verifiedBy": p.get("supplierVerifiedBy"),
                      "title": p["title"][:70], "url": p["url"]}

rows = sorted(best.items(), key=lambda kv: kv[1]["cash"])
with open("alibaba_shortlist.csv", "w", newline="", encoding="utf-8") as f:
    w = csv.writer(f)
    w.writerow(["supplier", "first_order_usd", "moq", "unit_price", "years", "rating", "verified_by", "title", "url"])
    for name, r in rows:
        w.writerow([name, r["cash"], r["moq"], r["unit"], r["years"], r["rating"], r["verifiedBy"], r["title"], r["url"]])
print(f"{len(rows)} suppliers -> alibaba_shortlist.csv")

The filters (verifiedSuppliersOnly, maxMoq) run on Alibaba's side, so you only pay for products that already pass them. The years and rating cut runs locally because Alibaba has no filter for it.

Things that tripped me up

MOQ units differ. LED strips are sold by the meter in 42 of 75 listings, yoga mats sometimes by the dozen. Filter moqUnit before comparing prices across listings.
Sponsored listings repeat. 37 of 75 LED strip results were ads. Set includeAds: false for a clean comparison, or keep them and filter isAd later.
New suppliers aren't bad, just unproven. The cheapest verified earbud listing came from a 1-year-old supplier. I keep them in a separate tab and ask for samples first.
Prices are list prices. Shipping, customization and payment fees come on top. The quantity ladder in priceTiers shows how much the price drops at 500 or 1,000 units.

Run it on a schedule

Add a weekly schedule in Apify and join runs on productId to see price changes and new suppliers in your category. It also works from Make, n8n or Zapier (each has an Apify module that runs an actor and returns the dataset), or from an AI agent through the Apify MCP server.

Store page: https://apify.com/rel8ble/alibaba-product-search-scraper
Python examples (MIT): https://github.com/Rel8ble/alibaba-product-scraper-python

This article was drafted with AI and published by me.

Downloading an Alibaba supplier's whole catalog as JSON (and vetting suppliers with it)

Gio Rich — Tue, 27 Oct 2026 17:18:46 +0000

Searching Alibaba shows you products from hundreds of suppliers. Once you have a shortlist, the useful question flips: what else does this supplier sell, how focused is the catalog, which of their products actually sell, what is certified, and is the company behind it a 140-person factory or an 8-person trading office? That answer lives on the supplier's storefront (name.en.alibaba.com), 16 products per page, often 30 to 80 pages deep.

Copying that by hand gets old fast, so I wrote Alibaba Supplier Store Scraper to turn a store URL, a product URL or a keyword into one clean JSON row per product, over plain HTTP. This post covers how it works, calling it from Python and Node, what a row looks like, and a small project: scoring suppliers from their catalogs.

How it works

A supplier storefront page server-renders its modules as URL-encoded JSON inside module-data attributes: the supplier card, the store's own category tree, and the product list with paging. The actor decodes those, maps each product card to flat fields (price range, MOQ, certificates, sold in the last 180 days, orders, ready-to-ship, store category with its parent) and copies the supplier card onto every row: business type, supplier identity, years on Alibaba, verified staff count, store rating, the inspection company that verified it, ranking badges, main products and capability tags such as "ODM services available" or "Patents awarded (6)". No contact person names, phones or emails are collected.

After page 1 it knows the product count, so it queues exactly the pages it needs and reads them in parallel. Give it a product URL and it finds the supplier on the product page first; give it a keyword and it uses the JSON endpoint Alibaba's own search page calls to collect the suppliers behind the results. A keyword inside each store, ready-to-ship only, and price / MOQ filters are applied before anything is charged. It connects directly and only retries blocked requests through a proxy.

Calling it from Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("rel8ble/alibaba-supplier-store-scraper").call(run_input={
    "storeUrls": [
        "https://alextechnology.en.alibaba.com/",
        "https://www.alibaba.com/product-detail/High-Quality-PU-Yoga-Mat-Custom_1601669249206.html",
    ],
    "searchTerms": ["bluetooth speaker"],
    "maxStoresPerSearch": 3,
    "maxProductsPerStore": 50,
})

for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(p["supplierName"][:30], "|", p["storeCategory"], "|", p["priceText"], "| MOQ", p["moq"], "| sold", p["soldLast180Days"])

The same from Node:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('rel8ble/alibaba-supplier-store-scraper').call({
    storeUrls: ['alextechnology'],
    keywordInStore: 'earphone',
    readyToShipOnly: true,
    maxProductsPerStore: 0, // the whole matching catalog
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'ready-to-ship earphones from', items[0]?.supplierName);

What a row looks like

From a real run, trimmed:

{
    "productId": "1601240924267",
    "title": "HM11 Retro Bluetooth Speaker, Vintage Decor, Mini Wireless Bluetooth Speaker, Fashion Style Outdoor Accessories",
    "priceMin": 3.89,
    "priceMax": 4.49,
    "moq": 2,
    "moqUnit": "pieces",
    "readyToShip": true,
    "certificates": ["FCC", "DECLARATION OF CONFORMITY"],
    "soldLast180Days": 4,
    "orderCount": 3,
    "storeCategory": "Bluetooth Speaker",
    "supplierName": "Shenzhen Yuzhuo Technology Co., Ltd.",
    "supplierBusinessType": ["Trading Company"],
    "supplierIdentity": "Multispecialty Supplier",
    "supplierYearsOnAlibaba": 13,
    "supplierStaffCount": 8,
    "supplierRating": 4.4,
    "supplierVerifiedBy": "SGS Group",
    "supplierCapabilities": ["Registered trademarks (3)", "Patents awarded (2)", "ODM services available"],
    "storeTotalProducts": 271,
    "source": "search",
    "searchTerm": "bluetooth speaker"
}

Project: scoring suppliers from their catalogs

A supplier that sells yoga mats, mouse pads and flower pots is a different partner from one with 300 listings in a single category. With one run you can measure that:

from collections import Counter, defaultdict

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
by_store = defaultdict(list)
for r in rows:
    by_store[r["storeUrl"]].append(r)

print(f"{'supplier':32} {'focus':>5} {'certs':>5} {'selling':>7} {'staff':>5} {'years':>5} type")
for store, items in by_store.items():
    s = items[0]
    top_cat = Counter((i["storeCategory"] or "").split(" > ")[0] for i in items).most_common(1)[0][1]
    focus = top_cat / len(items)                                   # share of products in the biggest category
    certified = sum(bool(i["certificates"]) for i in items) / len(items)
    selling = sum(i["soldLast180Days"] > 0 or i["orderCount"] > 0 for i in items) / len(items)
    print(f"{s['supplierName'][:32]:32} {focus:5.0%} {certified:5.0%} {selling:7.0%} "
          f"{s['supplierStaffCount'] or '-':>5} {s['supplierYearsOnAlibaba'] or '-':>5} {'/'.join(s['supplierBusinessType'])}")

Focus, certification share and the share of listings with real sales are three quick signals you cannot get from search results alone. Pass the url of the products that survive to a detail scraper when you need full price ladders and lead times.

Pricing and limits

$1.50 per 1,000 products, no start fee. Products skipped by filters, duplicates, missing stores and failed requests are never charged. This is listing-level data: full quantity ladders, SKUs and specs are on product pages. Sales counts show on about a third of products in my tests; supplier rating, years, business type and verification on every row. Up to 4,000 products per store (scrape by category or keyword for bigger ones).

Store page: https://apify.com/rel8ble/alibaba-supplier-store-scraper

This article was drafted with AI and published by me.

Finding verified factories on Global Sources with Python, no browser

Gio Rich — Mon, 26 Oct 2026 17:31:15 +0000

Global Sources is the older, more curated cousin of Alibaba: a Hong Kong B2B marketplace where most suppliers are paying, ranked members, many of them verified on site as factories, and plenty exhibit at its trade shows. If you source products, it is the second place you check after Alibaba, and comparing the two by hand is slow. There is no public product API.

I'm an 18-year-old engineering student, and I built Global Sources Scraper to turn a keyword into clean JSON rows over plain HTTP. This post covers how it works, calling it from Python and Node, what a row looks like, and a small project: a shortlist of verified, low-MOQ factories for a product.

How it works

Global Sources' search page is a single-page app that loads its results from a JSON search endpoint, 80 products per call, with the filters (supplier location, verified business type, supplier ranking, years in business, certificates, FOB port, OEM, trade show) sent in the same request. The actor calls exactly that endpoint, pages through until your limit, and applies price and MOQ filters before a row is saved, so filtered-out products are never charged. It connects directly and only retries blocked requests through a proxy.

Each row has the product (title, URL, images, video, model number, category path), the price (FOB from / to in USD, price type), MOQ and unit, lead time and FOB port when given, and the supplier: name, homepage, country, star ranking P1-P6, years on Global Sources, business types, verified supplier and verified manufacturer badges, and trade show history.

Calling it from Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("rel8ble/global-sources-scraper").call(run_input={
    "searchTerms": ["yoga mat", "bluetooth speaker"],
    "maxResultsPerSearch": 200,
    "verifiedManufacturerOnly": True,
    "maxMoq": 1000,
    "maxPrice": 20,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["priceText"], "| MOQ", item["moq"], item["moqUnit"], "|", item["supplierName"], f"P{item['supplierLevel']}", item["supplierLocation"])

The same from Node:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('rel8ble/global-sources-scraper').call({
    searchTerms: ['led light'],
    supplierLocations: ['Vietnam', 'India'],
    minSupplierLevel: 5,
    maxResultsPerSearch: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const p of items) console.log(p.priceMin, p.moq, p.supplierName, p.supplierYearsOnGlobalSources, p.url);

What a row looks like

From the default demo run ("led light"), trimmed:

{
    "productId": "1230765239",
    "title": "Multi function LED Work Light | Rotatable, Magnetic Base & Rechargeable Spotlight with Multiple Light",
    "url": "https://www.globalsources.com/Work-light/LED-work-light-1230765239p.htm",
    "priceMin": 7.3,
    "priceMax": 7.5,
    "priceType": "PRICE_BY_ORDER_QUANTITY",
    "moq": 100,
    "moqUnit": "Boxes",
    "leadTimeDays": 7,
    "fobPort": "Ningbo",
    "categoryPath": ["Hardware", "Lighting & Electricals", "Industrial Lighting", "Work lights"],
    "supplierName": "Market Union Co. Ltd",
    "supplierUrl": "https://market-union.manufacturer.globalsources.com/",
    "supplierLocation": "China",
    "supplierYearsOnGlobalSources": 4,
    "supplierLevel": 6,
    "supplierBusinessTypes": ["Buying Office", "Trading Company", "Agent"],
    "verifiedSupplier": true,
    "verifiedManufacturer": false,
    "tradeShows": "Exhibited at 2 GS shows"
}

Project: a verified-factory shortlist

Goal: for a product, list verified manufacturers with an MOQ under 500, one line per supplier, cheapest first, with how many matching products each one lists.

from collections import defaultdict
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("rel8ble/global-sources-scraper").call(run_input={
    "searchTerms": ["silicone kitchen utensils"],
    "maxResultsPerSearch": 400,
    "verifiedManufacturerOnly": True,
    "maxMoq": 500,
})

suppliers = defaultdict(lambda: {"products": 0, "cheapest": None, "url": None, "level": None, "years": None})
for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    s = suppliers[p["supplierName"]]
    s["products"] += 1
    s["url"], s["level"], s["years"] = p["supplierUrl"], p["supplierLevel"], p["supplierYearsOnGlobalSources"]
    if p["priceMin"] and (s["cheapest"] is None or p["priceMin"] < s["cheapest"]):
        s["cheapest"] = p["priceMin"]

ranked = sorted(suppliers.items(), key=lambda kv: (kv[1]["cheapest"] or 1e9))
for name, s in ranked[:20]:
    print(f"${s['cheapest'] or '?':>6} | P{s['level']} | {s['years']:>2} yrs | {s['products']:>3} products | {name} | {s['url']}")

Run it weekly on a schedule and diff the supplier set to see who is new in your category. Pair it with an Alibaba search on the same keyword and you have a two-marketplace price comparison in one script.

Pricing and limits

$1.50 per 1,000 products, no start fee. Products removed by your filters, duplicates and failed requests are never charged. Search results only: full spec sheets and per-quantity price tiers live on product pages, which this version doesn't open. Certificates are rarely printed on search cards, so the certificate fields are often empty, but the certificate filters work because Global Sources applies them itself. Some suppliers hide prices (about 5% in tests).

Store page: https://apify.com/rel8ble/global-sources-scraper

This article was drafted with AI and published by me.

Getting full Alibaba product pages as JSON: price tiers, SKUs, specs and the supplier behind them

Gio Rich — Sun, 25 Oct 2026 17:17:56 +0000

Alibaba search results tell you a price range and an MOQ. The decisions get made on the product page: what the unit price is at 500 pieces versus 5,000, how long production takes at your quantity, which variants exist, whether the CE or FCC certificate is real (with a number), and whether the supplier is a 140-person factory with a 2,400 m² floor or a three-person trading office. Copying that out of 20 tabs by hand is the slow part of sourcing.

I'm an 18-year-old engineering student, and I built Alibaba Product Details Scraper to turn product URLs, product IDs or a keyword into one clean JSON row per product, over plain HTTP. This post covers how it works, calling it from Python and Node, what a row looks like, and a small project: a side-by-side supplier comparison for a shortlist.

How it works

An Alibaba product page carries its data as one big JSON object that the page renders from. The actor fetches the page, cuts that object out with a string-aware brace walk, and maps it to flat fields: the quantity price ladder, MOQ, SKU matrix, specifications, certificates, lead time bands, sample price, customization options, package size and weight, and the supplier card (business type, years, staff, factory size, store rating, on-time dispatch rate, response time, online revenue band, orders in the last six months, ranking badge). No contact person names, phones or emails are collected.

Give it keywords instead of URLs and it first calls the JSON endpoint Alibaba's own search page uses, then opens each product it finds. Removed products are reported in a run summary and never charged. It connects directly and only retries blocked requests through a proxy.

Calling it from Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("rel8ble/alibaba-product-details-scraper").call(run_input={
    "productUrls": [
        "https://www.alibaba.com/product-detail/ALOVA-Latest-Model-Bluetooth-6-0_1601511059774.html",
        "1601617846699",
    ],
    "searchTerms": ["yoga mat"],
    "maxProductsPerSearch": 30,
})

for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    tiers = ", ".join(f"{t['minQuantity']}+: ${t['price']}" for t in p["priceTiers"])
    print(p["title"][:50], "| MOQ", p["moq"], "|", tiers or p["priceText"], "|", p["supplierName"])

The same from Node:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('rel8ble/alibaba-product-details-scraper').call({
    searchTerms: ['bluetooth speaker'],
    maxProductsPerSearch: 20,
    includeAds: false,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const p of items) console.log(p.priceMin, p.moq, p.leadTimes[0]?.days, p.supplierYearsOnAlibaba, p.certificates.map((c) => c.name).join('/'), p.url);

What a row looks like

From a real run, trimmed:

{
    "productId": "1601511059774",
    "title": "ALOVA Latest Model Bluetooth 6.0 Earphone IPX7 Bone Conduction Headset Waterproof Headphone Wireless Earbuds with Mic",
    "priceTiers": [
        { "minQuantity": 10, "maxQuantity": 89, "price": 9.9 },
        { "minQuantity": 90, "maxQuantity": 1999, "price": 8.5 },
        { "minQuantity": 2000, "maxQuantity": 4999, "price": 7.4 },
        { "minQuantity": 5000, "maxQuantity": null, "price": 6.5 }
    ],
    "moq": 10,
    "samplePrice": 22,
    "skuCount": 4,
    "leadTimes": [{ "minQuantity": 2, "maxQuantity": 90, "days": 31 }, { "minQuantity": 91, "maxQuantity": 1000, "days": 35 }],
    "certificates": [{ "name": "FCC", "type": "PRODUCT", "number": "2AP4POPENEAR-X1", "validity": "07/25/2022 - 12/30/9999" }],
    "packageSize": "15.5X9X18",
    "packageWeightKg": 0.5,
    "supplierName": "Shenzhen Alex Technology Co., Ltd.",
    "supplierBusinessType": ["Manufacturer", "Trading Company"],
    "supplierYearsOnAlibaba": 11,
    "supplierStaffCount": 142,
    "supplierFactorySizeSqm": 2400,
    "supplierRating": 4.5,
    "onTimeDeliveryRate": "100.0%",
    "onlineRevenue": "US$1,500,000+",
    "ordersLast6Months": 242,
    "supplierRanking": "#2 leading manufacturer in Earphone & Headphone & Accessories"
}

Project: a supplier comparison for your order size

Goal: for a shortlist of products, print the unit price at the quantity you actually plan to order, the lead time for that quantity, the landed weight, and the supplier signals that matter, sorted by price.

from apify_client import ApifyClient

QTY = 1000
client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("rel8ble/alibaba-product-details-scraper").call(run_input={
    "searchTerms": ["insulated water bottle"],
    "maxProductsPerSearch": 40,
    "includeAds": False,
})

def price_at(p, qty):
    for t in p["priceTiers"]:
        if t["minQuantity"] <= qty and (t["maxQuantity"] is None or qty <= t["maxQuantity"]):
            return t["price"]
    return p["priceMin"]

def lead_at(p, qty):
    for l in p["leadTimes"]:
        if l["minQuantity"] <= qty <= (l["maxQuantity"] or 10**9):
            return l["days"]
    return None

rows = []
for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    if p["moq"] and p["moq"] > QTY:
        continue
    rows.append((price_at(p, QTY), lead_at(p, QTY), p))

for price, lead, p in sorted(rows, key=lambda r: r[0] or 1e9)[:15]:
    certs = "/".join(c["name"] for c in p["certificates"][:3]) or "-"
    print(f"${price:>6} @ {QTY} | {lead or '?':>3} days | {p['packageWeightKg'] or '?'} kg | "
          f"{p['supplierYearsOnAlibaba']} yrs | {'verified' if p['verifiedSupplier'] else 'unverified':10} | "
          f"{p['onTimeDeliveryRate'] or '-':>6} on time | {certs} | {p['supplierName']}")

The cheap way to cover a whole category is two steps: scan thousands of search cards with our Alibaba search scraper (filter by price, MOQ and country there), then send only the shortlist's url column to this actor for the full pages.

Pricing and limits

$2.50 per 1,000 products, no start fee. Removed products, invalid URLs, duplicates and failed requests are never charged. The long HTML description is not included (Alibaba loads it in a separate frame). Supplier capability fields appear only when the supplier shows them: staff count and factory size on about a quarter of products in my tests, online revenue on about half. Prices are USD list prices as shown to a US visitor.

Store page: https://apify.com/rel8ble/alibaba-product-details-scraper

This article was drafted with AI and published by me.

Getting Better Business Bureau (BBB) business listings as JSON with Python (ratings, accreditation, phones)

Gio Rich — Sat, 24 Oct 2026 17:15:32 +0000

The Better Business Bureau lists millions of businesses across the US and Canada, and every listing in its search carries a few things that are hard to get elsewhere in one place: a BBB letter rating from A+ to F, whether the business is BBB Accredited, a phone number, a street address and a category. For anyone building local lead lists (roofers in Houston, dentists in Toronto, HVAC companies in Phoenix) that is a clean starting point, and the rating is a quick signal of who is worth calling.

BBB has no public self-serve API. I'm an 18-year-old engineering student, and I built BBB Business Scraper to turn bbb.org searches into JSON. This post covers calling it from Python and Node, what a row looks like, how it gets past BBB's 225-result limit, and a small project: a weekly list of accredited, A-rated contractors.

How it works

The search page on bbb.org loads its results from a JSON endpoint, 15 businesses per page. The actor calls that same endpoint over plain HTTP, no browser, and keeps the business fields: name, category, rating, accreditation, phones, address, coordinates, the profile URL, the local BBB and the service area. BBB highlights the matched word with <em> tags in names, so those are stripped.

The catch is that BBB never returns more than 15 pages for one search, so 225 businesses, even when it says there are 1,954 plumbers around Denver. Page 16 doesn't error, it just hangs until Cloudflare gives up. So when you ask for more than 225, the actor runs narrower searches and merges them by id: one per rating grade (A, B, C, D, F), then per state BBB offers for that search, then per category, then per distance ring (5, 10, 25, 50 miles). A slice that is still too big is read in BBB's other sort orders (A-Z, Z-A, rating, distance each show a different 225), and as a last step the same slice is searched around the towns its businesses are in. Deeper slices are paged one page at a time and stop once pages stop bringing anything new. For plumber near Denver that reached 1,524 of the 1,954 BBB lists, in about 4 minutes and 1,200 requests.

Profile pages (complaints, reviews, owner names) are behind a Cloudflare bot check, so the actor doesn't touch them. Everything comes from the public search results.

Python example

pip install apify-client

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("rel8ble/bbb-business-scraper").call(run_input={
    "searchQueries": ["roofing"],
    "locations": ["Austin, TX"],
    "accreditedOnly": True,
    "ratings": ["A"],
    "maxDistanceMiles": 25,
    "maxItems": 60,
})

for b in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(b["name"], "|", b["rating"], "|", b["phone"], "|", b["city"], "|", b["profileUrl"])

In my test run every one of the 60 rows came back accredited and rated A+, all in Austin.

Node example

npm install apify-client

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const run = await client.actor('rel8ble/bbb-business-scraper').call({
    searchQueries: ['dentist', 'plumber'],
    locations: ['Vancouver, BC', 'M5V 2T6'],
    maxItems: 30,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'businesses');
console.log(items[0].name, '-', items[0].phone, '-', items[0].localBbb);

What a row looks like

{
    "id": "1296_90156205_690834",
    "businessId": "90156205",
    "name": "Ennis Plumbing LLC",
    "category": "Plumber",
    "categories": ["Plumber", "Commercial Plumber"],
    "rating": "A+",
    "ratingScore": 100,
    "accredited": true,
    "phone": "(720) 660-9812",
    "address": "4865 Golden Ct",
    "city": "Denver",
    "state": "CO",
    "postalCode": "80212",
    "country": "US",
    "latitude": 39.74,
    "longitude": -104.97,
    "profileUrl": "https://www.bbb.org/us/co/denver/profile/plumber/ennis-plumbing-llc-1296-90156205",
    "serviceAreas": ["Thornton, CO"],
    "localBbb": "BBB Great West + Pacific"
}

(The full row has a few more fields: all phone numbers, logo, review and quote links, the search it came from.) id is one business location; a company with several branches has one businessId and several rows.

Small project: accredited, A-rated contractors every week

If you sell to home-service businesses, the accredited A-rated ones are usually established and reachable. This script runs weekly, searches a few trades in a few cities, keeps only businesses it hasn't seen before and prints one line each.

import json, os
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
SEEN = "seen_bbb.json"
seen = set(json.load(open(SEEN))) if os.path.exists(SEEN) else set()

run = client.actor("rel8ble/bbb-business-scraper").call(run_input={
    "searchQueries": ["roofing contractors", "hvac", "electrician"],
    "locations": ["Houston, TX", "Dallas, TX", "Austin, TX"],
    "accreditedOnly": True,
    "ratings": ["A"],
    "maxDistanceMiles": 25,
    "maxItems": 0,
})

new = []
for b in client.dataset(run["defaultDatasetId"]).iterate_items():
    if b["businessId"] in seen or not b["phone"]:
        continue
    seen.add(b["businessId"])
    new.append(b)

for b in sorted(new, key=lambda x: (x["city"] or "", x["name"] or "")):
    print(f'{b["name"]} | {b["category"]} | {b["phone"]} | {b["city"]}, {b["state"]} | {b["profileUrl"]}')

json.dump(sorted(seen), open(SEEN, "w"))
print(len(new), "new businesses")

Deduplicating on businessId rather than id gives one line per company even when it has several branches. Put it on cron or an Apify schedule and push the lines into a CRM or a sheet.

Things to know

Price: $1.00 per 1,000 businesses, no start fee. 100 businesses is 10 cents.
The 225 limit is BBB's. Deep search is on by default and only kicks in when you ask for more than 225 from one search; the run summary shows BBB's count, what was reached and the coverage percent. Expect most, not all, of a very big search.
Wide area: a city search reaches far (Denver returns Wyoming and Nebraska too). Use maxDistanceMiles or states to tighten it.
Typos in places: BBB answers an unknown place by searching everything. The actor spots that, skips the search and doesn't charge for it.
No profiles, no personal data: complaints, reviews and owner names live on profile pages behind a bot check, which the actor doesn't open. E-mail addresses that look personal in free text are masked.
US and Canada: "City, ST", ZIP codes, Canadian postal codes and state or province codes all work.

Questions or broken fields: the Issues tab on the actor page comes straight to me.

BBB Business Scraper on Apify

This article was drafted with AI and published by me.

How to get Amazon search results as JSON (rank, price, rating, sponsored flag) on any marketplace with Python or Node

Gio Rich — Sat, 24 Oct 2026 05:21:17 +0000

Amazon's search page is the data everyone in e-commerce wants and nobody enjoys collecting: which products rank for a keyword, at what price, with how many ratings, how many sponsored slots sit above the first organic result, and how that changes by marketplace. The HTML is big, the card layout differs between marketplaces, prices come in a different format on every one of them, and Amazon blocks datacenter IPs with captchas, AWS WAF challenges and bot-manager interstitials.

I'm an 18-year-old engineering student, and I wrapped all of that in an actor called Amazon Search Scraper. This post shows how to call it from Python and Node, what the rows look like, and a small project: a daily keyword rank tracker.

How it works, briefly

You give it keywords (plus a marketplace, department, sort order and price range) or full Amazon search URLs with any filters already applied. It fetches the result pages over plain HTTP through residential proxies in the marketplace's country, no browser, and parses every product card: position, ASIN, title, price and list price, currency, rating, ratings count, "10K+ bought in past month", Best Seller / Amazon's Choice badges, deal and coupon text, delivery text, image and URL, with sponsored listings flagged and numbered separately from organic ones. It follows pagination until your limit, deduplicates ASINs per search, and retries blocked pages on a fresh session. Turn on includeDetails and it also opens each product page for brand, bullet points, seller, Best Sellers Rank, category path, images and the spec table.

Python example

pip install apify-client

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("rel8ble/amazon-search-scraper").call(run_input={
    "keywords": ["wireless earbuds", "bluetooth speaker"],
    "domain": "amazon.com",
    "department": "electronics",
    "sort": "relevance",
    "maxItemsPerSearch": 50,
    "includeSponsored": True,
})

for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    flag = "AD " if p["isSponsored"] else "   "
    print(f'{flag}{p["position"]:>3} {p["asin"]} {p["price"]!s:>8} {p["rating"]!s:>4} {p["ratingsCount"]!s:>8}  {p["title"][:60]}')

Output (shortened):

AD    1 B09XPX59JK    19.99  4.3    19200  Wireless Earbuds, Bluetooth 5.4 Headphones in Ear with 4 Noise
AD    2 B0D2HJDH94    28.99  4.3    12700  Wireless Bluetooth 5.4 Earbuds, LED Power Display Headphones
      3 B0FQFB8FMG   199.00  4.4    16100  Apple AirPods Pro 3 Wireless Earbuds with Active Noise Cancellation
      4 B0H5J3FDR2    20.98  4.6       48  Wireless Earbuds, Sports Bluetooth Headphones, Running Headphones

Node example

npm install apify-client

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const run = await client.actor('rel8ble/amazon-search-scraper').call({
    searchUrls: ['https://www.amazon.de/s?k=kopfh%C3%B6rer&i=electronics&rh=p_36%3A2000-5000'],
    maxItemsPerSearch: 30,
    includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const p of items) console.log(p.asin, p.price, p.currency, p.details?.brand, p.details?.bestSellersRank?.[0]);

What a row looks like

{
    "position": 3,
    "organicPosition": 1,
    "asin": "B0FQFB8FMG",
    "title": "Apple AirPods Pro 3 Wireless Earbuds with Active Noise Cancellation Live Translation, Heart Rate Sensing, ...",
    "price": 199,
    "priceText": "$199.00",
    "listPrice": 249,
    "currency": "USD",
    "rating": 4.4,
    "ratingsCount": 16100,
    "boughtLastMonth": 10000,
    "boughtLastMonthText": "10K+ bought in past month",
    "isSponsored": false,
    "isBestSeller": true,
    "isAmazonChoice": false,
    "dealText": null,
    "offersText": "7+ used & new offers",
    "deliveryText": "Join Prime to get FREE delivery Sat, Oct 10 Or Non-members get FREE delivery Tue, Oct 13",
    "imageUrl": "https://m.media-amazon.com/images/I/61solmQSSlL.jpg",
    "url": "https://www.amazon.com/dp/B0FQFB8FMG",
    "page": 1,
    "keyword": "wireless earbuds",
    "marketplace": "amazon.com",
    "scrapedAt": "2026-10-08T18:02:11.420Z"
}

Small project: a keyword rank tracker

Track where a set of ASINs rank for a keyword, organic and overall, once a day, and append to a CSV. Run it from cron or an Apify schedule.

import csv, datetime
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
KEYWORD = "wireless earbuds"
WATCH = {"B0FQFB8FMG", "B0D2HJDH94", "B09XPX59JK"}   # your ASINs and competitors

run = client.actor("rel8ble/amazon-search-scraper").call(run_input={
    "keywords": [KEYWORD], "domain": "amazon.com", "maxItemsPerSearch": 200,
})
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
today = datetime.date.today().isoformat()
ads_above_first_organic = sum(1 for p in items if p["isSponsored"] and p["position"] < next(q["position"] for q in items if not q["isSponsored"]))

with open("ranks.csv", "a", newline="") as f:
    w = csv.writer(f)
    for p in items:
        if p["asin"] in WATCH:
            w.writerow([today, KEYWORD, p["asin"], p["position"], p["organicPosition"], p["price"], p["rating"], p["ratingsCount"], p["isSponsored"]])
    w.writerow([today, KEYWORD, "ADS_ABOVE_FIRST_ORGANIC", ads_above_first_organic, "", "", "", "", ""])

print(f"{len(items)} products scanned, {len([p for p in items if p['asin'] in WATCH])} watched ASINs found")

A 200-product scan costs $0.40 at $2 per 1,000 results, so a 25-keyword daily tracker is about $10 a month.

Things to know

~300 products per search is where Amazon stops paginating for most keywords. Narrow by department or price band to see more.
Sponsored results rotate per request, so two runs minutes apart show different ads. organicPosition is the stable number.
Prices follow the visitor's country. The default residential proxy country matches the marketplace, so amazon.de quotes EUR; with a US proxy country it quotes export prices in USD. The currency field follows the text shown.
Brand is usually only on the product page, so it's null on search cards unless Amazon prints a brand row; use includeDetails when you need it.
Residential proxies are the default. Datacenter IPs work for a while and then hit captchas and WAF challenges; the actor retries on a fresh session, but residential is cheaper in retries than it costs in bandwidth (about 0.4 MB per search page).

If something breaks or a field is wrong, the Issues tab on the actor page reaches me directly.

Amazon Search Scraper on Apify

This article was drafted with AI and published by me.

One API for every company's job board (Greenhouse, Lever, Ashby, Workday, Workable...) with Python or Node

Gio Rich — Fri, 23 Oct 2026 17:42:29 +0000

Most companies don't host their own job listings. The careers page is a thin wrapper around an applicant tracking system: Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Workable, Recruitee, Personio, Teamtailor or BambooHR. Each of those publishes the board as a public JSON or XML feed, which is great, except that there are ten of them, every one with a different schema, pagination rule and date format, and half the time you don't even know which one a company uses.

I'm an 18-year-old engineering student, and I wrapped all ten behind one input and one output schema in an actor called Job Boards Scraper. This post shows how to call it from Python and Node, what the rows look like, and a small project: a daily "who started hiring for X" feed for sales prospecting.

How it works, briefly

You give it a list of entries. Each one can be an ATS board URL (boards.greenhouse.io/stripe, jobs.lever.co/palantir, jobs.ashbyhq.com/notion, nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite ...), a company careers page (notion.com/careers, where the embedded board is detected from the page) or just a company website or name (stripe.com, blueground), which is tried on every platform until a board with open jobs answers. Every job is then mapped to one schema: title, company, location (plus city, region, country), remote flag, department, team, employment type, salary range when published, posting date, full description as plain text, and the job and apply URLs. No browser, no scraping of rendered pages, just the platforms' own public endpoints over HTTP, so a 700-job board takes a couple of seconds.

Python example

pip install apify-client

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("rel8ble/ats-job-boards-scraper").call(run_input={
    "boards": [
        "https://boards.greenhouse.io/stripe",
        "https://jobs.ashbyhq.com/notion",
        "https://www.notion.com/careers",   # careers page: board detected
        "blueground",                        # bare company name: guessed
    ],
    "titleKeywords": ["engineer", "developer"],
    "locationKeywords": ["remote"],
    "maxJobsPerBoard": 100,
})

for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["company"], "|", job["title"], "|", job["location"], "|", job["publishedAt"][:10], "|", job["url"])

Output (shortened):

Stripe | Software Engineer, Infrastructure | Remote, US | 2026-09-24 | https://stripe.com/jobs/search?gh_jid=...
Notion | Software Engineer, Developer Platform | San Francisco, California | 2026-08-24 | https://jobs.ashbyhq.com/notion/1fc309c8-...

Node example

npm install apify-client

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const run = await client.actor('rel8ble/ats-job-boards-scraper').call({
    boards: ['https://jobs.lever.co/palantir', 'https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite'],
    titleKeywords: ['sales', 'account executive'],
    includeDescription: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'jobs');
console.log(items[0]);

What a row looks like

{
    "id": "1fc309c8-da20-4ff2-84c7-8b863ece2b0a",
    "title": "Software Engineer, Developer Platform",
    "company": "Notion",
    "ats": "ashby",
    "url": "https://jobs.ashbyhq.com/notion/1fc309c8-da20-4ff2-84c7-8b863ece2b0a",
    "applyUrl": "https://jobs.ashbyhq.com/notion/1fc309c8-da20-4ff2-84c7-8b863ece2b0a/application",
    "location": "San Francisco, California",
    "locations": ["San Francisco, California", "New York, New York"],
    "city": "San Francisco",
    "region": "California",
    "country": "United States",
    "workplaceType": "hybrid",
    "isRemote": true,
    "department": "Engineering",
    "team": "Engineering",
    "employmentType": "full-time",
    "salaryMin": 213000,
    "salaryMax": 320000,
    "salaryCurrency": "USD",
    "salaryText": "$213,000 - $320,000",
    "publishedAt": "2026-08-24T14:44:49.699Z",
    "description": "WHO WE ARE\n\nNotion is the collaborative AI workspace ...",
    "boardUrl": "https://jobs.ashbyhq.com/notion",
    "scrapedAt": "2026-10-08T17:45:45.963Z"
}

Small project: a daily hiring-signal feed

The classic sales play: a company that just opened three SDR roles is about to buy sales tooling; a company hiring a "Head of Data" is about to buy data infrastructure. Here's the whole thing in 40 lines. It keeps a JSON file of job ids it has seen and prints only the new ones.

import json, os
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
SEEN = "seen_jobs.json"
seen = set(json.load(open(SEEN))) if os.path.exists(SEEN) else set()

accounts = ["stripe", "notion", "https://jobs.lever.co/palantir", "bunq.com", "blueground"]

run = client.actor("rel8ble/ats-job-boards-scraper").call(run_input={
    "boards": accounts,
    "titleKeywords": ["sales development", "sdr", "account executive", "revenue operations"],
    "includeDescription": False,
})

new = []
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    key = f'{job["ats"]}:{job["id"]}'
    if key in seen:
        continue
    seen.add(key)
    new.append(job)

for job in new:
    print(f'NEW  {job["company"]:<12} {job["title"]:<50} {job["location"] or "-":<30} {job["url"]}')

json.dump(sorted(seen), open(SEEN, "w"))
print(f"{len(new)} new postings")

Run it from cron or an Apify schedule and pipe the output into Slack, a CRM task or a spreadsheet. The run costs $1 per 1,000 jobs, so a 500-account list with filtering costs a few cents a day.

Things to know

Ten platforms, not all of them. iCIMS, Taleo, SuccessFactors, Jobvite and fully custom career sites are reported as unresolved in the run summary rather than scraped.
Descriptions are free on Greenhouse, Lever, Ashby, Recruitee, Personio and Teamtailor. On SmartRecruiters, Workday, Workable and BambooHR they cost one extra request per job (still one result); set includeDescription: false for a fast count.
Company names come from the platform where it publishes one; for Lever, Ashby and Workday they're derived from the board slug (notion -> "Notion").
Dates: Workday only says "Posted 3 Days Ago", which is converted to a date; "Posted 30+ Days Ago" stays null.
Salary is a structured field on Lever, Ashby, Recruitee and Teamtailor; elsewhere it's parsed from the description when a range like "$120,000 - $150,000" is stated.

If something breaks or a field is wrong, the Issues tab on the actor page reaches me directly.

Job Boards Scraper on Apify

This article was drafted with AI and published by me.

How to get Amazon's full Best Sellers top 100 for any category and marketplace as JSON

Gio Rich — Thu, 22 Oct 2026 17:29:07 +0000

Amazon's Best Sellers pages are the simplest public signal of what's selling: a top 100 per category, per marketplace, refreshed hourly. They're also annoying to collect. Each page only renders 30 of its 50 products and loads the other 20 when you scroll, the two pages live behind a pg= parameter, prices come in a different format on every marketplace, and Amazon blocks most datacenter IPs after a few requests.

I'm an 18-year-old engineering student, and I wrapped all of that in an actor called Amazon Best Sellers Scraper. This post shows how to call it from Python and Node, what the data looks like, and one small project: a daily rank tracker for a category.

How it works, briefly

An Amazon list page embeds all 50 ASINs of the page with their ranks in a data attribute and renders the first 30 product cards. The other 20 come from a background call the page's own script makes when you scroll; the actor makes the same call on the same session, so you get all 50 per page and all 100 per list. Prices are parsed per locale ($1,234.56 and 20,46 € both work), the currency is set per marketplace, and the left-hand menu is read so you can pull every subcategory in one run. No browser; plain HTTP through residential proxies in the marketplace's country.

Python example

pip install apify-client

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("rel8ble/amazon-bestsellers-scraper").call(run_input={
    "categoryUrls": [
        "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
        "https://www.amazon.de/gp/new-releases/ce-de/",
    ],
    "maxItemsPerList": 100,
})

for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(p["marketplace"], p["rank"], p["asin"], p["price"], p["currency"], p["rating"], p["title"][:60])

Node example

npm install apify-client

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const run = await client.actor('rel8ble/amazon-bestsellers-scraper').call({
    categoryIds: ['electronics'],
    domain: 'amazon.co.uk',
    listType: 'bestsellers',
    maxItemsPerList: 50,
    includeSubcategories: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const p of items) console.log(p.listName, p.rank, p.asin, p.price, p.currency, p.title);

What a result looks like

{
    "rank": 1,
    "asin": "B08JHCVHTY",
    "title": "blink plus plan with monthly auto-renewal",
    "price": 11.99,
    "priceText": "$11.99",
    "currency": "USD",
    "rating": 4.4,
    "ratingsCount": 280900,
    "imageUrl": "https://images-na.ssl-images-amazon.com/images/I/31YHGbJsldL._AC_UL900_SR900,600_.png",
    "url": "https://www.amazon.com/dp/B08JHCVHTY",
    "listType": "bestsellers",
    "listName": "Best Sellers in Electronics",
    "categoryId": "electronics",
    "categoryPath": "Any Department > Electronics",
    "listUrl": "https://www.amazon.com/gp/bestsellers/electronics",
    "marketplace": "amazon.com",
    "page": 1,
    "scrapedAt": "2026-10-08T00:36:48.481Z"
}

A small project: a daily rank tracker

Schedule the actor once a day on the Apify platform (Schedules tab, pick the actor, paste the input), then append each day's dataset to a local SQLite table and chart any ASIN's rank over time:

import sqlite3, datetime as dt
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
db = sqlite3.connect("ranks.db")
db.execute("""create table if not exists ranks(
    day text, marketplace text, list_url text, asin text, rank int, price real, rating real, ratings_count int, title text,
    primary key(day, list_url, asin))""")

# Latest finished run of the actor (the scheduled one)
runs = client.actor("rel8ble/amazon-bestsellers-scraper").runs().list(desc=True, limit=1).items
dataset_id = runs[0]["defaultDatasetId"]
day = dt.date.today().isoformat()

for p in client.dataset(dataset_id).iterate_items():
    db.execute("insert or replace into ranks values (?,?,?,?,?,?,?,?,?)",
               (day, p["marketplace"], p["listUrl"], p["asin"], p["rank"], p["price"], p["rating"], p["ratingsCount"], p["title"]))
db.commit()

# Which products climbed the most since yesterday?
for row in db.execute("""
    select t.asin, y.rank as yesterday, t.rank as today, t.title
    from ranks t join ranks y on y.asin = t.asin and y.list_url = t.list_url and y.day = date(t.day, '-1 day')
    where t.day = ? order by (y.rank - t.rank) desc limit 10""", (day,)):
    print(row)

One list a day is 100 results, or 15 cents, so a 20-category tracker runs for about $3 a month.

Things I learned building it

30 vs 50: the "missing" 20 products per page aren't on page 2, they're lazy-loaded. If you scrape the HTML only, you get 60 of the 100 and a gap at ranks 31-50 and 81-100.
Prices: 97% of products on a 200-item test had one. The rest are subscriptions or out-of-stock items Amazon lists without a price.
Movers & Shakers, Most Wished For and Most Gifted currently render without a server-side product grid, so the actor only promises Best Sellers and New Releases. URLs of the other kinds are accepted and come back empty, with the reason in the run summary.
Residential proxies are the default. Datacenter IPs work for a while and then hit captchas; the actor retries on a fresh session, but residential is cheaper in retries than it costs in bandwidth (about 0.5 MB per page).

If something breaks or a field is wrong, the Issues tab on the actor page reaches me directly.

Amazon Best Sellers Scraper on Apify

This article was drafted with AI and published by me.