DEV Community: Gio Rich

Getting eBay search results and prices as JSON with Python (no API key, no browser)

Gio Rich — Thu, 05 Nov 2026 18:18:17 +0000

eBay is still the biggest open price list for second-hand and new-in-box products: phones, LEGO sets, watches, car parts, graphics cards. If you flip things, price your own stock, or want to know what a used iPhone 13 actually goes for in the UK versus Germany, its search pages are the data.

eBay's official APIs need a developer account, OAuth and an application review, and the one that answered "what did this sell for" (Finding API, findCompletedItems) was switched off in 2025. I'm an 18-year-old engineering student, and I built eBay Search Scraper to turn eBay searches into clean rows instead. This post covers calling it from Python and Node, what a row looks like, and a small project: a weekly median price for one product on three eBay sites.

How it works

eBay's search page (/sch/i.html?_nkw=...) is still server-rendered HTML: every listing is an <li class="s-card"> with the title, price, condition, shipping line, location, "N sold" and the seller's feedback right in the markup. With _ipg=240 one request returns 240 listings, so 10,000 listings are about 42 requests. The actor reads those pages over plain HTTP with Crawlee and parses them with cheerio; no browser.

Three things cost real debugging time and are worth knowing if you ever scrape eBay yourself:

Fingerprint and IP. eBay's edge answers a Chrome, Safari or Edge TLS fingerprint coming from a server with an instant 403 "Error Page", and it answers every datacenter IP that way, Apify's shared datacenter proxies included. A Firefox desktop fingerprint over HTTP/2 from a residential IP is served normally; HTTP/1.1 is 403 again. The actor therefore defaults to Apify's residential proxy. A home IP works for a few dozen requests, then gets a "Pardon Our Interruption" challenge.
Prices follow the visitor. eBay converts prices and shipping into the local currency of the IP it sees: the same earbuds came back as $39.95 from a US exit and as R$ 77.98 from a Brazilian one. The actor tries exits in the eBay site's own country first, falls back to any country if that pool is rejected, and always stores priceText and currency next to the numeric price, so nothing is silently mixed up.
Sold listings are behind a login now. LH_Sold=1&LH_Complete=1 redirects guests to eBay's sign-in page in most regions (I tried from home and through residential proxies; sign-in every time). The actor still accepts listingType: "sold" and retries with a warmed-up session, but treat it as experimental; failed searches are not charged. Active listings are the product.

Placeholder cards ("Shop on eBay", item 123456) and the "results matching fewer words" tail are dropped, sponsored listings are flagged from the page's own JSON model, and rows are deduplicated by item id within a search.

Python example

pip install apify-client

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("rel8ble/ebay-search-scraper").call(run_input={
    "queries": ["iphone 13 128gb"],
    "site": "ebay.co.uk",
    "conditions": ["used"],
    "buyingFormat": "buy-it-now",
    "priceMin": "100",
    "priceMax": "400",
    "sort": "price-asc",
    "maxItemsPerSearch": 240,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f'{item["price"]} {item["currency"]} | {item["condition"]} | {item["shippingText"]} | {item["title"][:60]} | {item["itemUrl"]}')

call() waits for the run to finish (one page takes a few seconds; large runs a few minutes). The dataset is also available as CSV or Excel from the Apify console, or over the REST API with ?format=csv.

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/ebay-search-scraper').call({
    startUrls: ['https://www.ebay.de/sch/i.html?_nkw=lego&LH_Auction=1&_sop=1'],
    maxItemsPerSearch: 240,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const it of items) console.log(it.price, it.currency, it.bidCount, 'bids', it.timeLeft, '|', it.title);

Pasting an eBay URL works on any country site; the filters in the URL are used as they are.

What a row looks like

A real row from a run on 2026-10-20 (wireless earbuds, ebay.com):

{
    "itemId": "126409498277",
    "title": "NEW Skullcandy Riff Wireless Bluetooth On-Ear Headphones with Mic Black",
    "condition": "Brand New",
    "price": 39.95,
    "priceText": "$39.95",
    "currency": "USD",
    "originalPrice": null,
    "discountPercent": null,
    "buyingFormat": "Buy It Now",
    "acceptsBestOffer": false,
    "bidCount": null,
    "timeLeft": null,
    "shippingText": "+$55.39 delivery",
    "shippingCost": 55.39,
    "freeShipping": false,
    "itemLocation": "United States",
    "soldCount": 340,
    "watchers": null,
    "sellerName": "alphadailydeals",
    "sellerFeedbackPercent": 99.8,
    "sellerFeedbackCount": 59300,
    "isSponsored": true,
    "categoryId": "112529",
    "imageUrl": "https://i.ebayimg.com/images/g/5p4AAOSwzAZjYuC9/s-l500.jpg",
    "itemUrl": "https://www.ebay.com/itm/126409498277",
    "site": "ebay.com",
    "listingType": "active",
    "sourceSearch": "\"wireless earbuds\", on ebay.com",
    "page": 1,
    "rank": 1
}

A marked-down listing in the same run came with "price": 79.99, "originalPrice": 99.99, "discountPercent": 20. Auction rows carry bidCount and timeLeft ("1 Gebot" and "33 Min" become 1 and "33 Min" on ebay.de), and European sites add sellerType: "private" or "business".

Small project: a weekly median price on three sites

Say you buy used iPhone 13s and want to know where they are cheapest this week. Run the same search on ebay.com, ebay.co.uk and ebay.de, keep only rows in the site's own currency, and take the median of price plus shipping.

import statistics
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
SITES = {"ebay.com": "USD", "ebay.co.uk": "GBP", "ebay.de": "EUR"}

for site, cur in SITES.items():
    run = client.actor("rel8ble/ebay-search-scraper").call(run_input={
        "queries": ["iphone 13 128gb"],
        "site": site,
        "conditions": ["used"],
        "buyingFormat": "buy-it-now",
        "includeSponsored": False,
        "maxItemsPerSearch": 240,
    })
    totals = []
    for r in client.dataset(run["defaultDatasetId"]).iterate_items():
        if r["currency"] != cur or r["price"] is None or r.get("priceTo"):
            continue  # skip rows eBay showed in another currency and price ranges
        totals.append(r["price"] + (r["shippingCost"] or 0))
    if totals:
        print(f"{site}: {len(totals)} listings, median {statistics.median(totals):.2f} {cur}, cheapest {min(totals):.2f}")

Run it on a schedule (Apify can run the actor on cron and call a webhook) and append the three numbers to a sheet. Three pages of 240 listings cost about $0.43.

Things to know

Price: $0.60 per 1,000 listings, no start fee. Apify's $5 monthly free credit covers roughly 8,000 listings.
Residential proxy is required and is the default. On pay-per-event pricing the compute and proxy bandwidth are paid by the developer, not added to your bill.
Check the currency. currency and priceText tell you what eBay actually printed; the run summary lists the currencies seen and the proxy exit country.
About 10,000 results per search is eBay's ceiling. Split big searches by price band, category or condition.
Search pages only: no descriptions, item specifics or buyer data. Seller username and feedback score are the only personal data, and they are public on every result page.

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

eBay Search Scraper on Apify

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.

How to build a local business lead list from YellowPages in 10 minutes

Gio Rich — Thu, 05 Nov 2026 17:05:23 +0000

If you sell to local businesses, you need a list before you can do anything else. Copying listings out of a directory by hand works for 20 businesses and falls apart at 200. This walkthrough gets you a clean spreadsheet of US businesses from YellowPages.com in about ten minutes, for well under a dollar.

Full disclosure: the scraper used here is one I built and sell on Apify. The steps for cleaning and checking the list work the same with any source.

Step 1: Pick one niche and one city

Start narrow. "Roofing contractors in Austin, TX" gives you a list you can write a single pitch for. "Home services in Texas" gives you a pile of businesses with nothing in common.

Write down three things before you start:

Search terms: the words a customer would type, such as roofing contractors or dentist
Locations: City, ST or a ZIP code, US only
Size: how many businesses you can actually follow up with

If you want more than one search, every term runs in every location. Two terms in three cities is six searches.

Step 2: Do a small test run

Create a free Apify account, open the YellowPages scraper and paste this into the JSON input tab:

{
  "searchTerms": ["roofing contractors"],
  "locations": ["Austin, TX"],
  "maxResults": 20
}

maxResults applies per term and location pair, and you pay per business saved, so keep it at 20 until the output looks right. Sponsored ads are left out by default, which you usually want.

Press Start. When it finishes, look at the results and ask two questions. Are these the businesses you meant? Do the listings have the phone and website columns filled in? If the results look off, change the search term before you spend more. "Roofing contractors" and "roofers" can return different results, so try both.

Step 3: Run the full list

Raise maxResults to the size you want. Setting it to 0 pulls everything for that search, up to about 3,000 businesses.

Add includeDetails if you need email addresses:

{
  "searchTerms": ["roofing contractors"],
  "locations": ["Austin, TX"],
  "maxResults": 250,
  "includeDetails": true
}

This opens each business page to collect email (when one is listed), hours, description, social links and year founded. It's slower. Many listings have no email, so expect blanks in that column.

At $1.50 per 1,000 results, 250 businesses costs about 38 cents, plus a tiny fee to start the run.

If you'd rather script it, Apify's API runs the same job and returns a CSV:

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

The synchronous endpoint can time out on long runs. For a big list, start a normal run and download the dataset when it's done.

Step 4: Clean it in a spreadsheet

Export the results as CSV and open the file. A raw export needs a few minutes of work:

Remove columns you won't use. Name, phone, address, website, category and rating are usually enough. Keep email if you collected it.
Remove duplicates by phone number. A business can appear under several listings, and the phone number is a more reliable match than the name.
Check the addresses. Directory results can include businesses from nearby towns. Filter by city and decide whether those are in your territory.
Check the categories. Search terms catch near matches, so a roofing search may return general contractors or supply stores. Delete any that you can't sell to.

Step 5: Add one column that makes it useful

A list becomes useful when it tells you who to contact first. Add a priority column and sort on something you can see in the data:

Selling websites: businesses with an empty website column go first, after you search the name to confirm the directory isn't just missing the URL.
Selling reputation services: businesses with a low rating or few reviews go first.
Selling to established companies: use the years in business field to find the ones that have been around for a while.

Spot-check 10 rows against the live listing before you rely on the list. Directory data goes stale. Phones get disconnected and businesses close, so check any lead before you build a pitch around it.

Before you contact anyone

Check the rules that apply to you. In the US, CAN-SPAM requires a real postal address and a working opt-out in commercial email, and calls and texts have their own rules, including the Do Not Call registry. Other countries can be stricter, and some require consent first.

If you'd rather have someone else do this, I pull 250 local leads for $30 at fiverr.com/rel8ble.

Written with AI assistance.

Finding Canadian businesses that need marketing help, using YellowPages.ca data in Python

Gio Rich — Wed, 04 Nov 2026 18:18:49 +0000

If you run a small web, SEO or ads agency in Canada, the hard part of prospecting is not finding businesses, it's finding the right ones. YellowPages.ca quietly tells you a lot about that: which listings are paid placements, which advertising tier each business is on, whether it has reviews, social profiles or published hours.

I built YellowPages.ca Scraper to turn a search like "electrician in Toronto ON" into one JSON row per business, over plain HTTP with no browser. This post shows how to call it from Python and Node, what the ad-signal fields mean, and a small script that splits a city's businesses into two pitch lists.

Calling it from Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("rel8ble/yellowpages-ca-scraper").call(run_input={
    "searchTerms": ["electrician", "roofing"],
    "locations": ["Toronto ON", "Ottawa ON"],
    "maxResultsPerSearch": 100,
    "scrapeDetails": True,   # hours, coordinates, social links, languages
})

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(len(rows), "businesses")

Terms can be English or French (avocat, plombier work), and locations are City PROVINCE. Every term runs in every location, and each row keeps searchKeyword, searchLocation, position and totalInSearch so you know where it came from.

The same from Node, starting from a search URL instead:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('rel8ble/yellowpages-ca-scraper').call({
    startUrls: ['https://www.yellowpages.ca/search/si/1/dentist/Vancouver+BC'],
    maxResultsPerSearch: 50,
    requireWebsite: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((b) => `${b.name} | ${b.phone} | ${b.website}`).join('\n'));

What a row looks like

A real row from an "electrician / Toronto ON" run on 27 Oct 2026, trimmed:

{
    "name": "Expert GTA Electric",
    "category": "Electricians & Electrical Contractors",
    "phone": "647-846-8903",
    "website": "https://expertgta.com/",
    "city": "East York",
    "province": "ON",
    "rating": 5,
    "reviewCount": 11,
    "openingHours": ["Monday 00:00-23:59", "Tuesday 00:00-23:59"],
    "socialLinks": [
        "https://www.facebook.com/ExpertGTAElectric/services/",
        "https://twitter.com/ExpGTAElectric",
        "https://www.instagram.com/expertgtaelectric/"
    ],
    "sponsored": true,
    "listingTier": "GSP",
    "searchKeyword": "electrician",
    "searchLocation": "Toronto ON",
    "totalInSearch": 1634
}

Two fields matter most for prospecting:

sponsored is true when the business bought one of the paid slots at the top of the results.
listingTier is YellowPages' own advertising tier for the listing (values like GSP, SP, L0-L2, LEGACY, NONE). Paid tiers mean the business already spends money on marketing; LEGACY / NONE means a basic or free listing.

In that 20-business Toronto sample, 10 were sponsored, 17 of 20 had no rating at all, 10 had no social links, 3 had no published hours and 2 had no website. That's the shape of most local trades: plenty of businesses, very little online reputation.

Project: two pitch lists from one run

The idea: a business that already pays for ads is a good prospect for "better results for the money you're spending". A business on a free listing with no reviews and no socials is a prospect for "you're invisible, here's the basics".

PAID_TIERS = {"GSP", "SP", "L0", "L1", "L2"}

def gaps(b):
    out = []
    if not b.get("website"):
        out.append("no website")
    if not b.get("reviewCount"):
        out.append("no reviews")
    if not b.get("socialLinks"):
        out.append("no social")
    if not b.get("openingHours"):
        out.append("no hours")
    return out

spenders = [b for b in rows if b.get("listingTier") in PAID_TIERS]
invisible = [b for b in rows
             if b.get("listingTier") not in PAID_TIERS and len(gaps(b)) >= 2]

print("Already paying for visibility (pitch: better ROI):")
for b in spenders:
    print(f"  {b['name'][:38]:38} {b['listingTier']:4} {b['phone']:14} {', '.join(gaps(b)) or 'solid profile'}")

print("\nFree listing, weak presence (pitch: get found):")
for b in sorted(invisible, key=lambda b: -len(gaps(b))):
    print(f"  {b['name'][:38]:38} {b['phone']:14} {', '.join(gaps(b))}")

On the Toronto electrician sample this gives 10 "spenders" (most with zero reviews despite paying for a top slot, which is a strong opener) and a short list of free-listing businesses missing two or more basics.

Because rows carry coordinates (17 of the 20 here) and serviceAreas, you can also drop both lists onto a map and plan calls by neighbourhood.

Getting emails

YellowPages.ca does not publish email addresses at all, so no scraper of it will give you emails. The practical route is to pass the website column to a site crawler such as my Website Contact Extractor, which reads each company's own site for emails and social profiles.

Pricing and limits

$0.50 per 1,000 businesses, no start fee, same price with or without business pages. Businesses dropped by your filters, duplicate sponsored placements (YellowPages repeats them on every page) and failed requests are not charged. It covers Canada only, up to 100 result pages per term and location (about 2,500 businesses), so split big cities by neighbourhood or postal code. YellowPages widens thin searches to nearby cities, so check the city column. Canada's anti-spam law (CASL) restricts commercial email, so check your outreach rules before you send anything.

Store page: https://apify.com/rel8ble/yellowpages-ca-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.

Building German B2B lead lists from Gelbe Seiten with Python

Gio Rich — Tue, 03 Nov 2026 18:34:10 +0000

If you sell to small and mid-sized businesses in Germany, Gelbe Seiten is still the most complete public list of who exists where: electricians, tax advisors, dentists, lawyers, agencies, restaurants, sorted by category (Branche) and city. A category page shows 50 businesses; the rest load 10 at a time behind a "Mehr Anzeigen" button, and most emails only appear on each business's own page.

I'm an 18-year-old engineering student, and I built Gelbe Seiten Scraper to turn "Steuerberater in München" into one clean JSON row per business, over plain HTTP. This post covers how it works, calling it from Python and Node, what a row looks like, and a small project: ranking a city's businesses for outreach.

How it works

The category page (/branchen/<category>/<city>) server-renders the first 50 listing cards plus the total count and the parameters of its own "load more" form. The actor reads the cards (name, phone, website, address, district, rating), then posts the same load-more request the page sends to get the rest, 10 per request, in parallel. With business pages switched on, it opens each /gsbiz/<id> page and reads the schema.org LocalBusiness JSON-LD (coordinates, opening hours, services, payment methods, last update) plus the contact block (email, fax, social links).

Free-text searches (/suche/...) are excluded by gelbeseiten.de's robots.txt, so the actor never follows a redirect there. If you type Hotels and that is not a category, it tries hotel; if nothing matches, the search is listed in the run summary and costs nothing. Filters (must have email / website / phone, minimum rating) run 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/gelbe-seiten-scraper").call(run_input={
    "categories": ["Steuerberater", "Zahnarzt"],
    "locations": ["München", "Hamburg"],
    "maxResultsPerSearch": 100,
    "requireEmail": True,
})

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

The same from Node:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('rel8ble/gelbe-seiten-scraper').call({
    startUrls: ['https://www.gelbeseiten.de/branchen/elektriker/berlin'],
    maxResultsPerSearch: 0, // every listing
    scrapeDetails: false, // list data only: ~50 businesses per request
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'electricians in Berlin');

What a row looks like

From a real run, trimmed:

{
    "name": "hansezahn I HAMBURG, Dr. Janke und Partner, Zahnärzte",
    "category": "Zahnärzte",
    "categories": ["Zahnärzte", "Schwerpunkt Endodontie", "Implantologie"],
    "phone": "040 6 53 99 82",
    "phoneE164": "+49406539982",
    "fax": "040 6 54 76 54",
    "email": "info@hansezahn-hh.de",
    "website": "http://www.hansezahn-hh.de",
    "address": "Rodigallee 250, 22043 Hamburg",
    "latitude": 53.57074,
    "longitude": 10.125491,
    "rating": 4.7,
    "reviewCount": 3,
    "openingHours": ["Monday 08:00-19:00", "Tuesday 07:30-19:00", "Wednesday 07:30-18:30"],
    "businessTypes": ["Dentist"],
    "premiumListing": true,
    "searchCategory": "Zahnarzt",
    "searchLocation": "Hamburg",
    "position": 9,
    "totalInSearch": 803
}

In a 120-business test (tax advisors and dentists in two cities), 93% of rows had an email, 90% a website and every row a phone number and coordinates.

Project: ranking a city's businesses for outreach

Say you sell websites or online booking to local businesses. The best prospects have a phone and email but a weak online presence: no website, few reviews, no opening hours online.

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

def score(b):
    s = 0
    s += 3 if not b["website"] else 0          # no website: the obvious pitch
    s += 2 if b["reviewCount"] < 3 else 0       # barely any reviews
    s += 1 if not b["openingHours"] else 0      # hours not published
    s += 1 if not b["premiumListing"] else 0    # not paying for visibility yet
    return s

leads = sorted((b for b in rows if b["email"] or b["phone"]), key=score, reverse=True)
print(f"{'business':40} {'score':>5} {'district':18} contact")
for b in leads[:15]:
    print(f"{b['name'][:40]:40} {score(b):5} {(b['district'] or b['city'])[:18]:18} {b['email'] or b['phone']}")

Because every row carries searchCategory, searchLocation and coordinates, the same dataset also answers "how many dentists per district" or feeds a map for territory planning.

Pricing and limits

$0.35 per 1,000 businesses as of 3 Nov 2026, no start fee, same price with or without business pages. Filtered businesses, duplicates, unknown categories and failed requests are never charged. Categories must be Gelbe Seiten's German names (zahnarzt, not dentist), Germany only, up to 5,000 businesses per category and city (split big cities by district). Business contact data of sole traders can be personal data under the GDPR, and German law limits unsolicited ads by email and phone, so check your outreach rules.

Store page: https://apify.com/rel8ble/gelbe-seiten-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.

How much of Amazon's first search page is ads? Measuring sponsored share per keyword with Python

Gio Rich — Mon, 02 Nov 2026 18:21:19 +0000

If you sell on Amazon, or you're deciding whether to, the question "can I rank for this keyword organically?" has a blunt first filter: how much of page one is already bought? A keyword where half the slots are ads is a pay-to-play keyword. A keyword where ads are pushed to the bottom is one where organic rank still matters.

You can eyeball this in a browser, but sponsored slots rotate on every load and nobody checks 50 keywords by hand. My Amazon Search Scraper returns every result card with position, organicPosition and an isSponsored flag, so ad pressure becomes a few lines of Python.

What one snapshot looked like

These numbers come from search pages the actor saved on 8 Oct 2026 (they're the parser's test fixtures, loaded from a US IP). One snapshot each, so treat them as an illustration, not a benchmark:

Search	Results on page	Sponsored	Distinct ad products	Organic in top 10
amazon.com "wireless earbuds", page 1	31	15 (48%)	10	3
amazon.com "wireless earbuds", page 2	21	5 (24%)	5	10
amazon.com "laptop" in Electronics, page 1	26	2 (8%)	2	10
amazon.de "Kopfhörer", page 1	32	16 (50%)	8	3

Three things stood out:

Earbuds and headphones are pay-to-play. On "wireless earbuds" the top 10 went ad, ad, organic, organic, organic, then five ads in a row. The first organic result was AirPods Pro 3 at position 3.
The same product buys more than one slot. The two ads at positions 1 and 2 (ASINs B09XPX59JK and B0D2HJDH94) showed up again at positions 6 and 7. On the German "Kopfhörer" page, 16 ad slots went to just 8 products, each one twice. Counting ad slots overstates how many competitors are advertising, so count distinct ASINs too.
"Laptop" barely had ads. Two sponsored cards, both at positions 22 and 23. The top of that page was all organic, mostly MacBook Air listings. High-ticket categories don't behave like cheap accessories.

On page 1 of "wireless earbuds", the ads were not worse products: median price $26.96 vs $24.99 for organic results, average rating 4.41 vs 4.26. Advertisers there are established sellers with tens of thousands of ratings.

The script

This runs one search per keyword, keeps sponsored cards (the default), and prints a table of ad pressure.

from collections import defaultdict
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
KEYWORDS = ["wireless earbuds", "standing desk", "yoga mat", "laptop stand", "phone case"]

run = client.actor("rel8ble/amazon-search-scraper").call(run_input={
    "keywords": KEYWORDS,
    "domain": "amazon.com",
    "maxItemsPerSearch": 60,      # roughly the first page or two
    "includeSponsored": True,
})

rows = defaultdict(list)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    rows[item["keyword"]].append(item)

print(f"{'keyword':<20}{'results':>8}{'ads':>6}{'ad %':>7}{'ad ASINs':>10}{'organic top10':>15}  first organic")
for kw in KEYWORDS:
    items = sorted(rows[kw], key=lambda p: p["position"])
    ads = [p for p in items if p["isSponsored"]]
    top10_organic = sum(1 for p in items if p["position"] <= 10 and not p["isSponsored"])
    first_org = next((p for p in items if not p["isSponsored"]), None)
    share = len(ads) / len(items) * 100 if items else 0
    print(f"{kw:<20}{len(items):>8}{len(ads):>6}{share:>6.0f}%{len({p['asin'] for p in ads}):>10}{top10_organic:>15}"
          f"  #{first_org['position'] if first_org else '-'} {(first_org or {}).get('title', '')[:40]}")

A few notes on the fields:

position counts every card in page order; organicPosition counts only non-sponsored ones and is null on ads. The difference between them for your own ASIN is how many ads sit above you.
The actor deduplicates ASINs within a search, so a product that holds two ad slots on the page is saved once. If you want the raw slot count like in my table above, that's what the page shows; the distinct-ASIN column is what you get from the dataset, and it's the more honest number anyway.
Sponsored slots rotate per request. For a real decision, run the same keywords a few times a day for a week (an Apify schedule does this) and average the ad share.

Turning it into a decision

A rough rule I'd use for a new product:

Ad share under 15% and the first organic result in the top 3: organic rank is reachable; spend on listing quality and reviews.
Ad share 30-50% and 3 or fewer organic results in the top 10: budget for PPC from day one, or pick a longer-tail keyword.
Same few ASINs holding multiple ad slots: a couple of well-funded sellers own the keyword. Check their ratingsCount before deciding to fight them.

Add boughtLastMonth and ratingsCount to the table and you also see whether the organic results that survive are small sellers or giants.

Cost and limits

$0.90 per 1,000 products plus a $0.00005 Apify actor-start charge; the five-keyword run above saves at most 300 products, so about $0.27. Prices follow the visitor's country (the amazon.de page above showed USD because it was loaded from a US IP; with a German proxy country it quotes EUR). Brand is usually only on product pages, so it's often null on search cards. Review text isn't included.

Store page: https://apify.com/rel8ble/amazon-search-scraper
Python example repo: https://github.com/Rel8ble/amazon-search-scraper-python
First tutorial (rank tracker): https://dev.to/rel8ble/how-to-get-amazon-search-results-as-json-rank-price-rating-sponsored-flag-on-any-marketplace-4ea8

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.

How to find local businesses with no website (or a dead one) from a raw lead list

Gio Rich — Mon, 02 Nov 2026 16:41:33 +0000

A raw list of local businesses isn't a lead list yet. It's a list of names. If you sell websites, SEO or ads, the useful question is which of those businesses have a visible problem you can fix: no website, a dead one, or one that hasn't been touched in years.

You can answer that for a few hundred businesses in about ten minutes with a small script. This walkthrough uses Node 18 or newer and has no dependencies.

Step 1: Get a CSV with four columns

The source doesn't matter. An export from a directory, a chamber of commerce member page or a list you already own all work. You need a header row with at least these columns:

name,phone,address,website
Acme Roofing,(512) 555-0100,"100 Main St, Austin, TX",acmeroofing.example

Leave website empty when a business has none.

Pick one niche in one city for your first run. A list of 200 roofers lets you write one pitch that fits all of them. A list of 200 mixed businesses doesn't.

Step 2: Save the script

Save this as audit-leads.mjs:

// usage: node audit-leads.mjs leads.csv > audited.csv
import { readFileSync } from 'node:fs';

function parseCsv(text) {
  const rows = [[]];
  let cell = '', quoted = false;
  for (let i = 0; i < text.length; i++) {
    const c = text[i];
    if (quoted) {
      if (c === '"' && text[i + 1] === '"') { cell += '"'; i++; }
      else if (c === '"') quoted = false;
      else cell += c;
    } else if (c === '"') quoted = true;
    else if (c === ',') { rows.at(-1).push(cell); cell = ''; }
    else if (c === '\n') { rows.at(-1).push(cell); cell = ''; rows.push([]); }
    else if (c !== '\r') cell += c;
  }
  rows.at(-1).push(cell);
  const [head, ...body] = rows.filter(r => r.some(v => v.trim()));
  return body.map(r => Object.fromEntries(
    head.map((h, i) => [h.trim().toLowerCase(), (r[i] ?? '').trim()])));
}

const phoneKey = s => (s || '').replace(/\D/g, '').slice(-10);
const siteKey = s => (s || '').toLowerCase()
  .replace(/^https?:\/\//, '').replace(/^www\./, '').split('/')[0];

function dedupe(leads) {
  const seen = new Set();
  return leads.filter(lead => {
    const keys = [phoneKey(lead.phone), siteKey(lead.website)].filter(Boolean);
    if (keys.some(k => seen.has(k))) return false;
    keys.forEach(k => seen.add(k));
    return true;
  });
}

async function checkSite(website) {
  if (!website) return { site: 'none', pitch: 'no website' };
  const host = website.replace(/^https?:\/\//i, '');
  for (const scheme of ['https', 'http']) {
    try {
      const res = await fetch(`${scheme}://${host}`, {
        signal: AbortSignal.timeout(10000),
        headers: { 'User-Agent': 'Mozilla/5.0' },
      });
      if ([401, 403, 429, 503].includes(res.status)) return { site: 'blocked', pitch: '' };
      if (!res.ok) return { site: `error ${res.status}`, pitch: 'broken website' };
      const html = await res.text();
      const years = [...html.matchAll(/(?:©|&copy;|copyright)[^<]{0,30}/gi)]
        .flatMap(m => m[0].match(/(?:19|20)\d\d/g) ?? []).map(Number);
      const out = {
        site: 'ok',
        https: res.url.startsWith('https:') ? 'yes' : 'no',
        mobile: /name=["']?viewport/i.test(html) ? 'yes' : 'no',
        copyright: years.length ? Math.max(...years) : '',
      };
      const dated = out.https === 'no' || out.mobile === 'no'
        || (out.copyright && out.copyright < new Date().getFullYear() - 2);
      return { ...out, pitch: dated ? 'dated website' : '' };
    } catch {}
  }
  return { site: 'dead', pitch: 'dead website' };
}

const leads = dedupe(parseCsv(readFileSync(process.argv[2], 'utf8')));
const results = [];
for (let i = 0; i < leads.length; i += 5) {
  const batch = leads.slice(i, i + 5);
  const checks = await Promise.all(batch.map(l => checkSite(l.website)));
  batch.forEach((l, j) => results.push({ ...l, ...checks[j] }));
}

const cols = [...new Set(results.flatMap(Object.keys))];
const esc = v => `"${String(v ?? '').replaceAll('"', '""')}"`;
console.log(cols.join(','));
for (const r of results) console.log(cols.map(c => esc(r[c])).join(','));

Step 3: Run it

node audit-leads.mjs leads.csv > audited.csv

It checks five sites at a time and gives each one 10 seconds. Open audited.csv in a spreadsheet and you'll have the original columns plus these:

site: none, ok, dead, blocked or an error code such as error 404
https, mobile, copyright: filled in for working sites
pitch: the problem to lead with, if there is one

Step 4: Check before you call

The script can get these wrong, so look before you use them in a pitch:

dead can be a slow server. A site that takes longer than 10 seconds looks the same as one that's gone. Open each one in a browser. Telling an owner their live site is down ends the conversation.
blocked means nothing. Bot protection often rejects scripts, so those sites get no pitch. Check by hand if the lead matters.
none may be out of date. The directory may simply not have the URL. Search the business name before you tell them they don't have a site.
copyright is a clue, not proof. Plenty of well-kept sites never update the footer. It's most useful alongside another sign, such as no mobile viewport tag.

Step 5: Sort into three groups

Filter on pitch and you get three lists:

No website or dead website. The easiest conversation, because the problem is yes or no. Open with what you saw: "I looked for your site and the link on your listing doesn't load."
Dated website. Mention the one thing you can show them, such as how the site looks on a phone. A screenshot works better than a claim.
Nothing flagged. Those businesses may still be good clients, but they need a different angle. Leave them for later.

Before you email anyone, check the rules that apply to you. In the US, CAN-SPAM requires a real postal address and a working opt-out in commercial email. Other countries are stricter, and some require consent first.

Doing this every month

New businesses open every month and existing sites go down, so save your input files and run the script again later. Comparing this month's output against last month's shows which sites went down recently, and those are good businesses to call.

If you'd rather skip building the list, I pull 250 local leads for $30 at fiverr.com/rel8ble, and my scrapers are at apify.com/rel8ble.

Written with AI assistance.

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.