DEV Community: KinderBB

Compare Shopee Prices in Python from Two Saved Dataset Exports

KinderBB — Sat, 05 Sep 2026 05:19:14 +0000

Price monitoring starts with a saved observation. It does not start with a
claim that a scraper keeps a historical-price database.

The Shopee Product Scraper returns product rows from a run. If you save the
Dataset export from two dated runs, you can compare those observations locally
with a small Python command. The helper in the examples repository reads two
JSON arrays, matches the same listing, and reports four outcomes:
price_changed, unchanged, new, and missing.

This is deliberately a developer workflow. The comparator makes no storefront
request, Apify request, login, or currency conversion. It cannot reconstruct a
price that you did not save.

Disclosure: I build and monetize this Actor. This is an affiliate link;
I may earn a commission if you subscribe through it.

The row identity matters

The comparison key is the exact tuple:

(market, shop_id, product_id)

A product ID by itself is not enough. The same seller and product identifiers
must stay attached to the storefront where they were observed. Keep at least
these fields in every downloaded row:

Field	Why keep it
`market`	Separates storefront observations
`shop_id`	Identifies the seller
`product_id`	Identifies the listing
`currency`	Makes the numeric amount interpretable
`price`	The observed numeric price; zero is valid
`canonical_url`	Lets a reviewer inspect the exact listing reference
`source_fetched_at`	Records when the selected source supplied the row
`source_mode`	Preserves whether the row came from public search or an index

Keep IDs as strings when they arrive as strings. That preserves leading zeroes
and very large IDs. Do not deduplicate by title: two sellers can use similar
titles, and one search result can be adjacent to the query you entered.

Create two local exports

Run the Actor separately when you need a later observation, then download each
default Dataset as JSON. Name the files by their observation time, such as
before.json and after.json. The Actor is the collection step; the helper is
the local comparison step.

For a fully local smoke test, create a fresh temporary directory first. The
commands below use shell noclobber as a second guard, so they cannot replace
saved exports elsewhere. These are test-only rows, not evidence from Shopee:

git clone https://github.com/DataKazKN/shopee-product-scraper-examples.git
cd shopee-product-scraper-examples
git checkout --detach d857edaecbc66f1b2dbb8112fc3c4e5f8b3fad59
repo_dir="$PWD"
fixture_dir="$(mktemp -d "${TMPDIR:-/tmp}/shopee-price-fixture.XXXXXX")"
(
  set -C
  cd "$fixture_dir"

  cat > before.json <<'JSON'
[
  {
    "market": "th",
    "shop_id": "demo-shop-1",
    "product_id": "demo-product-1",
    "currency": "THB",
    "price": 1200,
    "canonical_url": "https://example.test/th/demo-shop-1/demo-product-1",
    "source_fetched_at": "2026-09-01T08:00:00Z",
    "source_mode": "search_index"
  },
  {
    "market": "th",
    "shop_id": "demo-shop-2",
    "product_id": "demo-product-2",
    "currency": "THB",
    "price": 800,
    "canonical_url": "https://example.test/th/demo-shop-2/demo-product-2",
    "source_fetched_at": "2026-09-01T08:00:00Z",
    "source_mode": "shopee_public_search"
  }
]
JSON

  cat > after.json <<'JSON'
[
  {
    "market": "th",
    "shop_id": "demo-shop-1",
    "product_id": "demo-product-1",
    "currency": "THB",
    "price": 1300,
    "canonical_url": "https://example.test/th/demo-shop-1/demo-product-1",
    "source_fetched_at": "2026-09-05T08:00:00Z",
    "source_mode": "search_index"
  },
  {
    "market": "th",
    "shop_id": "demo-shop-3",
    "product_id": "demo-product-3",
    "currency": "THB",
    "price": 950,
    "canonical_url": "https://example.test/th/demo-shop-3/demo-product-3",
    "source_fetched_at": "2026-09-05T08:00:00Z",
    "source_mode": "shopee_public_search"
  }
]
JSON

  python3 "$repo_dir/python/compare_snapshots.py" before.json after.json --pretty
)

The example.test URLs above are intentionally synthetic, and the temporary
directory is separate from the repository. Replace the fixture workflow with
your saved Dataset exports for a real comparison; do not point --output at an
existing export.

Run the standard-library CLI

Use the reviewed Shopee examples commit from the setup above, then run:

python3 python/compare_snapshots.py before.json after.json --pretty

To keep the report, choose a new filename:

python3 python/compare_snapshots.py before.json after.json \
  --output price-report.json --pretty

The output path uses exclusive creation. It refuses to replace an input, an
existing report, or a symlink, so an accidental rerun cannot destroy the
source bytes. Use another report name when the path already exists.

For the synthetic files above, an abridged result shape is:

{
  "currency": "THB",
  "price_changed": [
    {
      "market": "th",
      "shop_id": "demo-shop-1",
      "product_id": "demo-product-1",
      "currency": "THB",
      "canonical_url": "https://example.test/th/demo-shop-1/demo-product-1",
      "previous_price": 1200,
      "current_price": 1300,
      "previous_canonical_url": "https://example.test/th/demo-shop-1/demo-product-1",
      "current_canonical_url": "https://example.test/th/demo-shop-1/demo-product-1",
      "source_fetched_at": "2026-09-05T08:00:00Z",
      "previous_source_fetched_at": "2026-09-01T08:00:00Z",
      "current_source_fetched_at": "2026-09-05T08:00:00Z"
    }
  ],
  "unchanged": [],
  "new": [
    {
      "market": "th",
      "shop_id": "demo-shop-3",
      "product_id": "demo-product-3",
      "current_price": 950,
      "current_source_fetched_at": "2026-09-05T08:00:00Z"
    }
  ],
  "missing": [
    {
      "market": "th",
      "shop_id": "demo-shop-2",
      "product_id": "demo-product-2",
      "previous_price": 800,
      "previous_source_fetched_at": "2026-09-01T08:00:00Z"
    }
  ]
}

The real report also includes schema_version, snapshot row counts, and a
counts object. Every row retains its exact IDs and any available canonical
URL or timestamp; the abbreviated view above is still synthetic, not Actor
evidence.

Read the four categories correctly

price_changed means the identity exists in both arrays and the numeric price differs.
unchanged means the identity exists in both arrays and the price is equal.
new means the identity appears only in the later saved search.
missing means the identity appears only in the earlier saved search.

missing is not out_of_stock. A listing can disappear because the later
search returned a different slice, an index changed, the source was incomplete,
or the query limits changed. The comparator does not convert absence into an
inventory claim. Keep the Actor's stock evidence beside the row; labels such as
public_search_listing_available or indexed_variations_available describe
what that selected source exposed, not an exact unit quantity.

Timestamps and indexed rows

Check source_fetched_at yourself before interpreting the two files as earlier
and later observations. The helper carries timestamp strings through; it does
not parse dates or enforce chronological order. The field records when the selected
source supplied the row, not a guarantee that the marketplace changed at that
instant. Preserve source_mode as well: public search and indexed results are
different evidence lanes. Keep the original exports beside the report: the
comparator report does not include source_mode. An indexed row may be stale between indexing and
collection, so it should not be described as live inventory.

The comparator validates every input row before matching. Duplicate identities,
missing market, shop_id, or product_id, negative, missing or non-finite prices,
booleans and null prices, and mixed currencies fail with a diagnostic. A
zero price is valid. Different currencies fail rather than being silently
converted.

Run the local contract tests with:

python3 -m unittest discover -s tests -v

The test rows are synthetic and are not source evidence. The command does not
mutate either input; it only reads the files and writes a new report when you
select a path that does not exist.

What the dated owner check proves

On 5 September 2026, public build 0.1.24 was checked in the owner UI with
run oBQBFizSZ6AXwliIF. It returned 10 Thailand iPhone 17-family rows in 27
seconds, with observed THB prices from 29,700 to 44,980. The rating scope was
seller; stock evidence was public_search_listing_available; optional
images, reviews, and sold fields were absent. The selector lists 14 storefronts
plus automatic URL detection, but this single run does not verify every market.
Argentina keyword search is unavailable. It is one dated
owner observation, not historical-price, savings, customer, or guarantee
proof.

The useful next step is simple: save the next compatible Dataset export and
compare it with the first one under the same market and currency rules.

Run Shopee Product Scraper on Apify

I build and monetize this Actor. This is an affiliate link; I may earn a commission if you subscribe through it.

How to Scrape Shopee Product Data by Keyword with Apify

KinderBB — Wed, 26 Aug 2026 13:24:34 +0000

The useful result is not a page of product cards. It is a Dataset where each
row has a stable Shopee product identity, local price and currency, seller,
rating, availability evidence, and canonical URL.

In one bounded Indonesia test, the workflow below returned 10 unique, complete
IDR rows in about 34 seconds. Nine titles matched AirPods; Shopee also returned
one adjacent Apple iPhone 15 result. That is a good example of both the value
and the boundary: public marketplace search is useful, but it is not a promise
of perfect keyword precision.

Disclosure: I built the Apify Actor used in this guide. Successful runs
can generate pay-per-event revenue for the Actor developer. The evidence in
this article comes from one bounded owner-run test, not an external customer
case study.

What you will collect

The Actor accepts either public Shopee product URLs or keywords. This tutorial
uses keyword discovery and asks for no Shopee login, user cookies, or proxy
configuration in the input.

A complete product row can contain:

market and local currency;
product_id and shop_id as exact strings;
product title, price, and canonical URL;
seller name and rating when the source identifies the rating scope;
listing or variant availability evidence;
source_mode, source_fetched_at, and completeness metadata.

Availability evidence is not the same as exact stock quantity. A listing can
be observed as available while stock.quantity remains null.

Start with a small keyword run

Open Shopee Product Scraper on Apify.

Use this input:

{
  "searchTerms": ["airpods"],
  "market": "id",
  "sort": "sales",
  "maxItems": 10,
  "maxPages": 10
}

Why start at 10 products?

You can inspect every row before scaling.
Runtime and maximum charge stay easy to understand.
Relevance problems are visible instead of buried in a large export.
A failed or incomplete candidate does not become a misleading Dataset row.

The input selector contains 14 official Shopee storefronts. Singapore is
Verified in the current Store contract. The other 13, including Indonesia,
remain Beta pending additional market-local canaries. The Indonesia result in
this tutorial is one point-in-time keyword proof, not blanket verification of
every Indonesia workflow.

Run it from the Apify Console

Choose Indonesia as the storefront.
Enter airpods under keyword discovery.
Select Best-selling.
Set the result limit to 10.
Start the run.
Open the Dataset when the run succeeds.

Check the first rows before downloading anything. Confirm that:

market is id;
currency is IDR;
the product and shop IDs are present;
the title matches the product URL identity;
the seller and rating fields have the expected scope;
the stock object explains its evidence instead of inventing a quantity.

In the cited run, all 10 rows passed those completeness checks. One title was
an adjacent Apple product rather than an AirPods listing, so downstream users
should still filter titles, IDs, sellers, or categories for their specific
research question.

Call the same Shopee product scraper with cURL

Load your Apify token from an environment variable. Never paste the real token
into source code, an AI prompt, a screenshot, or a public tutorial.
Create or copy the token in Apify Console,
then store it locally as APIFY_API_TOKEN before running the command.

curl -sS --request POST \
  "https://api.apify.com/v2/acts/kazkn~shopee-product-scraper-no-login/run-sync-get-dataset-items?clean=true&format=json" \
  --header "Authorization: Bearer ${APIFY_API_TOKEN}" \
  --header "Content-Type: application/json" \
  --data '{
    "searchTerms": ["airpods"],
    "market": "id",
    "sort": "sales",
    "maxItems": 10,
    "maxPages": 10
  }'

This endpoint waits for the run and returns Dataset items. For longer jobs,
start an asynchronous Actor run and retrieve its default Dataset separately.

Use JavaScript

Install the official Apify client in your project and keep the token in the
environment:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
  token: process.env.APIFY_API_TOKEN,
});

const run = await client.actor('kazkn/shopee-product-scraper-no-login').call({
  searchTerms: ['airpods'],
  market: 'id',
  sort: 'sales',
  maxItems: 10,
  maxPages: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems({
  clean: true,
});

const idrRows = items.filter((item) =>
  item.market === 'id' && item.currency === 'IDR'
);

console.log(idrRows.map(({ title, price, seller, canonical_url }) => ({
  title,
  price,
  seller,
  canonical_url,
})));

Use the field names shown by the actual Dataset schema. If you transform rows,
keep product_id, shop_id, market, and currency alongside the values so
you do not merge different storefront products by title alone.

Export to CSV or Excel

From the Dataset page, choose CSV or Excel for spreadsheet work. JSON is better
when you need nested stock evidence or provenance fields.

Before comparing prices:

filter to the market you intend to study;
keep the local currency column;
remove adjacent or irrelevant titles for your query;
deduplicate by market, shop ID, and product ID;
treat source_fetched_at as the observation time;
do not compare IDR, SGD, MYR, or other local amounts without currency conversion.

What happens to incomplete products?

The Actor uses a fail-closed row contract. If required identity, price,
currency, seller, rating, or availability evidence cannot be proven, the
candidate is skipped before Dataset push.

That has two practical consequences:

a run can return fewer products than the input limit;
an incomplete candidate is not charged as a result event.

Apify platform usage is included in the active Actor price. Check the current
Store pricing table before a large run and keep the first test bounded.

Common questions

Does this use an official Shopee API?

No claim is made about an official Shopee API. This tutorial calls the Apify
Actor API. The Actor reads public or indexed product sources and validates rows
before emission.

Are all 14 storefronts equally reliable?

No. The selector exposes 14 official storefront options, but the current Store
contract marks Singapore Verified and the other 13 Beta pending market-local
canaries.

Is the keyword search perfectly precise?

No. The bounded Indonesia test matched 9 of 10 titles and included one adjacent
Apple product. Use the returned identities and fields to apply your own
downstream relevance rules.

Does `in_stock` mean an exact quantity is available?

No. Read the stock evidence field. Listing or variation availability can be
observed while the exact quantity remains unknown.

Run the bounded workflow

Start with one storefront, one keyword, and 10 products. Validate the Dataset,
then increase only the limit your workflow actually needs.

Copy-ready Python, JavaScript, cURL, and n8n examples are available in the
public GitHub repository.

👉 Run Shopee Product Scraper on Apify

Find YouTube Channels by Topic, Language, and Country

KinderBB — Tue, 25 Aug 2026 00:30:02 +0000

Most tools that find YouTube channels by topic shrink discovery into a single keyword and a single results page. That ignores the language, country, and niche vocabulary that actually shape the creator pool.

“AI automation” in English, “automatisation IA” in French, and “automatización con IA” in Spanish do not return the same creator pool. Country filters add another problem: a creator’s language, search region, declared country, and inferred geography are not interchangeable.

Here is a reproducible way to discover channels without building a seed list first.

Start from a market matrix

Write the requested market as separate dimensions:

niches = ["AI automation", "B2B SaaS"]
languages = ["en", "fr"]
countries = ["US", "CA", "GB", "FR"]

This is more useful than concatenating everything into one long search phrase. It lets the discovery layer try multiple relevant combinations while keeping a global cap on search calls.

The channel URLs you already know can still be included as optional seeds. They should not define the whole market.

Use worldwide language mode when country is not the brief

A French-language campaign is not necessarily a France campaign.

French-speaking creators can publish from Canada, Belgium, Switzerland, Morocco, Senegal, or anywhere else. If language matters and location does not, use:

run_input = {
    "preset": "qualified_shortlist",
    "niches": ["AI agents", "business automation"],
    "languages": ["fr"],
    "countries": [],
    "worldwideLanguageMode": True,
    "maxChannels": 10,
    "videosAnalyzedPerChannel": 10,
    "maximumSearchCalls": 12,
}

This guides discovery by language without pretending that every returned creator lives in one country.

Run the discovery from Python

pip install apify-client
export APIFY_API_TOKEN="..."

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_API_TOKEN"])

run_input = {
    "preset": "qualified_shortlist",
    "searchQueries": [
        "AI automation tutorials",
        "B2B SaaS growth",
    ],
    "niches": ["AI automation", "B2B SaaS"],
    "languages": ["en", "fr"],
    "countries": ["US", "CA", "GB", "FR"],
    "worldwideLanguageMode": False,
    "excludedKeywords": ["compilation", "reupload"],
    "minSubscribers": 1_000,
    "maxSubscribers": 500_000,
    "minVideosPerMonth": 1,
    "lastUploadWithinDays": 90,
    "maxChannels": 10,
    "videosAnalyzedPerChannel": 10,
    "maximumSearchCalls": 16,
}

run = client.actor("kazkn/youtube-creator-lead-finder").call(
    run_input=run_input,
)

items = client.dataset(run["defaultDatasetId"]).list_items().items

The output is deduplicated by stable channelId inside the run. That matters because the same creator can match several topics, languages, country hints, or search phrases.

Preserve what matched

A useful discovery row should explain why the channel entered the shortlist.

for item in items:
    print({
        "channel": item["channelName"],
        "matched_queries": item.get("matchedQueries", []),
        "matched_languages": item.get("matchedLanguages", []),
        "matched_countries": item.get("matchedCountries", []),
        "primary_language": item.get("primaryLanguage"),
        "declared_country": item.get("declaredCountry"),
        "inferred_countries": item.get("inferredCountries", []),
        "warnings": item.get("warnings", []),
    })

The matched* fields describe the search request. They are not automatically confirmed creator attributes.

Declared country is not inferred country

When public channel metadata includes a country, keep it as declaredCountry.

When geography is inferred from public signals, keep it in inferredCountries with countryConfidence. Never overwrite the declared field with a guess. If no defensible location signal exists, leave it unknown.

The same rule applies to language. Keep the primary language, detected languages, and confidence visible instead of turning a search hint into a fact.

Qualify after discovery

Topic relevance alone can return inactive or commercially weak channels. The second pass should check:

last upload date;
videos published in the last 30 and 90 days;
estimated monthly cadence;
recent median and average views;
engagement when public counts make it calculable;
Shorts, long-form, and live ratios;
public business-contact evidence when the brief requires it.

This two-pass design keeps discovery broad enough to find unfamiliar creators while spending enrichment work only on plausible candidates.

Keep the search bounded

Multi-language and multi-country matrices can expand quickly. Use maximumSearchCalls as a global cap, start with 5–10 output channels, and widen one dimension at a time.

If a search returns zero rows, inspect the exclusions and warnings. Requiring a narrow country, high recent views, frequent uploads, a small subscriber band, one format, and a public contact simultaneously can correctly eliminate every candidate.

Try the niche finder Task

The public YouTube Channel Finder by Niche Task starts without mandatory channel URLs and opens with a bounded input you can edit:

Find YouTube channels by topic and market

For the full input and output contract, see YouTube Creator Lead Finder.

The goal is not to search more keywords. It is to keep discovery broad, qualification explicit, and every uncertain attribute honest.

YouTube Channel Scraper in Python: Filter Active Creators

KinderBB — Tue, 25 Aug 2026 00:29:28 +0000

A YouTube channel scraper in Python can collect channel names, subscriber counts, and URLs. It gets the data. That solves extraction, not qualification.

For outreach, the expensive mistake is not missing one channel. It is spending time on channels that stopped publishing, no longer reach viewers, use the wrong content format, or expose no public business-contact route.

This tutorial builds a bounded Python workflow that returns active creator prospects instead of a raw channel dump.

Define active before scraping

“Active” needs a rule. A practical first pass might require:

at least one video per month;
a public upload within the last 60 days;
at least 1,000 median views across a recent sample;
5,000–250,000 subscribers;
long-form or Shorts content that matches the offer.

Those values are not universal. A thumbnail agency, affiliate manager, recruiter, and mobile-app sponsor will use different thresholds. The important part is to write the rule before seeing the results.

Install the Apify client

pip install apify-client

Load your token from an environment variable. Never place it in the script or commit it to Git.

export APIFY_API_TOKEN="..."

Run a qualified channel search

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_API_TOKEN"])

run_input = {
    "preset": "qualified_shortlist",
    "niches": ["AI automation", "B2B SaaS"],
    "languages": ["en"],
    "countries": ["US", "CA", "GB"],
    "worldwideLanguageMode": False,
    "minSubscribers": 5_000,
    "maxSubscribers": 250_000,
    "minVideosPerMonth": 1,
    "lastUploadWithinDays": 60,
    "minRecentMedianViews": 1_000,
    "contentFormats": ["long-form", "Shorts"],
    "requirePublicBusinessContact": False,
    "maxChannels": 10,
    "videosAnalyzedPerChannel": 10,
    "maximumSearchCalls": 12,
}

run = client.actor("kazkn/youtube-creator-lead-finder").call(
    run_input=run_input,
)

dataset = client.dataset(run["defaultDatasetId"])
creators = dataset.list_items().items

The Actor discovers candidates from the requested niches and queries. Channel URLs remain optional. It deduplicates output by channelId inside the run and writes one Dataset row per qualified channel.

Inspect recent performance, not lifetime totals

For each returned creator, the most useful review fields are recent:

for creator in creators:
    print({
        "channel": creator["channelName"],
        "url": creator["channelUrl"],
        "subscribers": creator.get("subscriberCount"),
        "last_upload": creator.get("lastUploadAt"),
        "videos_per_month": creator.get("estimatedVideosPerMonth"),
        "median_views": creator.get("recentMedianViews"),
        "score": creator.get("opportunityScore"),
        "reasons": creator.get("opportunityReasons", []),
        "warnings": creator.get("warnings", []),
    })

Median recent views are especially useful because one viral upload can distort an average. The sample is still bounded, so keep its warnings and do not present the metric as a complete channel history.

Match the content format to the offer

A channel can be active and still be the wrong prospect.

A long-form editing service may prioritize longFormRatio.
A vertical-video agency may prioritize shortsRatio.
A webinar or streaming product may prioritize liveRatio.

The output also includes a format confidence value. Shorts classification uses a duration heuristic from available public API data, so uncertain cases should remain visible rather than being forced into a perfect category.

Keep geography and language evidence separate

Search region, declared country, inferred country, and detected language are different facts.

The Dataset keeps them separate through fields such as:

declaredCountry;
inferredCountries;
countryConfidence;
primaryLanguage;
detectedLanguages;
languageConfidence.

If the brief asks for French-speaking creators worldwide, leave countries empty and set worldwideLanguageMode to True. Do not silently turn the search region into the creator’s declared location.

Export the shortlist to CSV

import csv

columns = [
    "channelId",
    "channelName",
    "channelUrl",
    "subscriberCount",
    "lastUploadAt",
    "estimatedVideosPerMonth",
    "recentMedianViews",
    "shortsRatio",
    "longFormRatio",
    "publicBusinessEmail",
    "contactSourceUrl",
    "opportunityScore",
]

with open("qualified-youtube-creators.csv", "w", newline="", encoding="utf-8") as file:
    writer = csv.DictWriter(file, fieldnames=columns, extrasaction="ignore")
    writer.writeheader()
    writer.writerows(creators)

Keep contactSourceUrl, opportunityReasons, and warnings in the production export. They are the audit trail behind the row.

Public contacts are evidence, not enrichment

The workflow can collect a professional email, website, social profile, or management route only when the creator exposed it in accessible public channel text.

It does not reveal YouTube’s protected business-email field, bypass CAPTCHA, sign in, guess private addresses, or fetch linked websites. An empty contact field is preferable to an invented address.

Start with a bounded public Task

The public Export Qualified YouTube Channels to CSV Task opens with a small editable input and the qualified Dataset view:

Run the CSV-ready YouTube channel scraper

For the complete input schema, output contract, limits, and live pricing, see YouTube Creator Lead Finder.

A useful scraper does not stop when it has extracted the channel. It stops when the row is qualified enough for a human to make the next decision.

Build a YouTube Channel Finder in Python That Qualifies Creators

KinderBB — Mon, 24 Aug 2026 23:58:37 +0000

A basic YouTube channel finder returns channels that match a name or topic. That is useful for lookup. It is not enough for creator outreach.

If you are building a sponsor list, recruiting educators, or selling a service to creators, the real question is narrower:

Which channels match my niche, still publish, reach enough viewers, and expose a public route for business contact?

This tutorial builds that workflow in Python. It starts without a seed list, discovers candidates from a niche, qualifies recent public performance, and returns one structured Dataset row per channel.

The result we want

The input should describe the opportunity, not a pile of channel URLs:

run_input = {
    "preset": "qualified_shortlist",
    "niches": ["AI automation", "B2B SaaS"],
    "languages": ["en"],
    "countries": ["US", "CA", "GB"],
    "worldwideLanguageMode": False,
    "minSubscribers": 5_000,
    "maxSubscribers": 250_000,
    "minVideosPerMonth": 1,
    "lastUploadWithinDays": 60,
    "minRecentMedianViews": 1_000,
    "contentFormats": ["long-form", "Shorts"],
    "requirePublicBusinessContact": False,
    "maxChannels": 10,
    "videosAnalyzedPerChannel": 10,
    "maximumSearchCalls": 12,
}

The output should be reviewable without opening every channel manually. Useful fields include:

channel identity and URL;
subscriber count and recent upload date;
videos published in the last 30 and 90 days;
estimated videos per month;
recent median and average views;
engagement when the public counts make it calculable;
Shorts, long-form, and live ratios;
declared country, inferred countries, and confidence kept separate;
public business email, website, or social route when explicitly exposed;
an opportunity score plus the reasons behind it.

That is the difference between a channel scraper and a creator-prospecting dataset.

Why subscriber count is a weak filter by itself

Subscriber count is easy to retrieve, so many YouTube scraping tutorials stop there. But two channels with 50,000 subscribers can be completely different prospects:

one published yesterday and regularly reaches 8,000 views;
the other last uploaded nine months ago;
one is mostly Shorts while your offer is for long-form editing;
one covers your niche consistently while the other mentioned it once;
one publishes a business email in the channel description while the other does not expose a public contact.

A useful YouTube creator finder therefore has to qualify the recent channel state, not only copy lifetime totals.

Run the Actor from Python

Install the Apify client:

pip install apify-client

Store your Apify token in an environment variable. Do not paste it into source code, a notebook, a screenshot, or a public repository.

export APIFY_API_TOKEN="..."

Then call the Actor and retrieve its default Dataset:

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_API_TOKEN"])

run_input = {
    "preset": "qualified_shortlist",
    "niches": ["AI automation", "B2B SaaS"],
    "languages": ["en"],
    "countries": ["US", "CA", "GB"],
    "worldwideLanguageMode": False,
    "minSubscribers": 5_000,
    "maxSubscribers": 250_000,
    "minVideosPerMonth": 1,
    "lastUploadWithinDays": 60,
    "minRecentMedianViews": 1_000,
    "contentFormats": ["long-form", "Shorts"],
    "requirePublicBusinessContact": False,
    "maxChannels": 10,
    "videosAnalyzedPerChannel": 10,
    "maximumSearchCalls": 12,
}

run = client.actor("kazkn/youtube-creator-lead-finder").call(
    run_input=run_input
)

items = client.dataset(run["defaultDatasetId"]).list_items().items

for creator in items:
    print(
        creator["channelName"],
        creator["channelUrl"],
        creator.get("recentMedianViews"),
        creator.get("opportunityScore"),
    )

The Actor writes one deduplicated row per channelId within the run. Separate runs use separate Datasets, so the same channel can legitimately appear again in a later search.

Search by language worldwide

Country and language are different filters. A French-speaking creator might be based in France, Canada, Belgium, Switzerland, Morocco, or somewhere else entirely.

To find French-speaking creators without forcing one country:

run_input = {
    "preset": "quick_leads",
    "niches": ["AI agents"],
    "languages": ["fr"],
    "countries": [],
    "worldwideLanguageMode": True,
    "maxChannels": 5,
    "videosAnalyzedPerChannel": 5,
    "maximumSearchCalls": 5,
}

The discovery hints guide the search. The output still keeps confirmed language evidence and confidence separate from geography. A search region is not silently presented as a creator’s declared country.

Require activity and recent performance

For outreach, “active” should be explicit. Three inputs do most of the work:

{
    "minVideosPerMonth": 2,
    "lastUploadWithinDays": 45,
    "minRecentMedianViews": 2_000,
}

The Actor samples a bounded number of recent videos per candidate. It calculates cadence over 30 and 90 days, then computes recent median and average views from the available sample.

Median views are especially useful because one viral upload can inflate the average. You should still inspect the sample size and warnings before treating any metric as complete.

Filter by content format

The same niche can contain very different production workflows. A thumbnail agency may want long-form channels. A vertical-video editor may want Shorts-heavy creators. A webinar platform may prefer live streams.

{
    "contentFormats": ["long-form"]
}

The output exposes shortsRatio, longFormRatio, liveRatio, and formatConfidence. Shorts detection from the official API uses a documented duration heuristic, so the Dataset can include a warning instead of pretending the classification is exact.

Treat public contacts as evidence, not enrichment

A YouTube email finder can mean two very different things:

collect a business email the creator explicitly published; or
reveal or guess an address the creator did not expose.

This workflow only does the first.

{
    "preset": "contact_ready",
    "requirePublicBusinessContact": True,
    "contactTypes": ["business_email", "website", "social"],
}

Each returned contact keeps its type, value, source URL, collection time, public status, and confidence. The current provider reads public channel text. It does not access YouTube’s protected business-email field, bypass CAPTCHA, sign in, guess private addresses, or fetch linked websites.

If a protected email is unavailable, that absence is a real result. It should not be replaced by a guessed pattern.

Export to CSV without flattening away the evidence

Apify can export the Dataset directly to CSV, JSON, or Excel. If you need a small CSV for manual review, keep the qualification and provenance columns:

import csv

columns = [
    "channelId",
    "channelName",
    "channelUrl",
    "primaryLanguage",
    "declaredCountry",
    "subscriberCount",
    "lastUploadAt",
    "estimatedVideosPerMonth",
    "recentMedianViews",
    "publicBusinessEmail",
    "contactSourceUrl",
    "opportunityScore",
]

with open("youtube-creators.csv", "w", newline="", encoding="utf-8") as file:
    writer = csv.DictWriter(file, fieldnames=columns, extrasaction="ignore")
    writer.writeheader()
    writer.writerows(items)

Do not drop contactSourceUrl, opportunityReasons, or warnings in the production pipeline. They are what let a human review why a creator qualified and where a contact came from.

Keep the run bounded

YouTube discovery has quota and latency costs. A sensible workflow performs cheap discovery first, then enriches only the best candidates.

Start small:

5–10 qualified channels;
5–10 recent videos checked per channel;
one or two niches;
a bounded search-call budget;
no public-contact requirement until you confirm the niche produces enough candidates.

Then tighten the filters. Requiring a contact, high cadence, high median views, a narrow country, and a small subscriber band all at once can correctly return zero rows.

Try the preconfigured YouTube channel finder

The quickest path is the public YouTube Channel Finder by Niche Task. It opens with a bounded, editable input and the qualified-creator Dataset view:

Run the YouTube Channel Finder by Niche

For all filters, output fields, limits, and live pricing, use the full YouTube Creator Lead Finder.

The useful output is not a longer list. It is a list you can explain, review, and act on.