DEV Community: Joshua Smith

Find the questions nobody answered on your YouTube channel, ranked by how many viewers want the answer

Joshua Smith — Fri, 30 Oct 2026 13:10:09 +0000

If your channel teaches something (a product, a library, a craft), the comment section is a support inbox nobody assigned. Questions pile up under tutorials, some get answered by other viewers, and the ones that matter most get buried. This post builds a weekly queue of unanswered questions: collect the comments with their replies, rebuild each thread, keep questions nobody on your team has answered, and rank them by how many viewers care.

YouTube Studio can filter your own comments to the ones you have not responded to, and for one person on one channel that may be enough. The script adds what Studio does not: replies from teammates count as answered, only questions are kept, the list is ranked, and it covers several channels and becomes a file you can share.

What counts as unanswered

A top-level comment goes in the queue when:

It asks something. A sentence ending in ? or starting with a question word, the same rule as the viewer-questions post earlier in this series.
Nobody on your side replied. No reply from the channel itself (isByVideoOwner) and none from a teammate's channel.
The whole thread was read. If the Actor did not deliver all of a comment's replies, the script can't know whether you answered, so it says "unknown" instead of guessing.

Viewers answering each other doesn't count as answered. Treat it as a ranking signal: a thread with five viewer replies is a question several people are stuck on, and the community answer may be wrong.

The input

Best Damn YouTube Comments Scraper reads comments through the official YouTube Data API v3, without a browser or login. For a weekly queue covering the last month:

{
    "startUrls": ["https://www.youtube.com/@YourChannel"],
    "maxVideosPerChannel": 30,
    "sortBy": "time",
    "publishedAfter": "30 days",
    "includeReplies": true,
    "maxComments": 0,
    "authorData": "include"
}

includeReplies: true is required, since the replies are how you tell answered from unanswered.
maxComments: 0 removes the per-video cap. Replies count toward the cap, so with a cap a busy video can use it all on a few long threads; in a test with a 300-comment cap, one video returned only 20 top-level comments. The 30-day window is what keeps the run small.
sortBy: "time" with publishedAfter lets the Actor stop paging once it reaches older comments.
authorData: "include" is needed here to recognise teammates' replies by channel ID. The script uses the IDs for that check and does not write names to the output.

maxVideosPerChannel: 30 reads your 30 most recent uploads. Questions on older videos are not in the queue; raise the number if your back catalogue keeps getting questions.

The script

import csv, re
from collections import defaultdict
from datetime import datetime, timezone
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
TEAM = {"UCxxxxxxxxxxxxxxxxxxxxxx"}  # channel IDs of teammates who reply for you

run = client.actor("josh99smith/youtube-comments-scraper").call(run_input={
    "startUrls": ["https://www.youtube.com/@YourChannel"], "maxVideosPerChannel": 30,
    "sortBy": "time", "publishedAfter": "30 days", "includeReplies": True,
    "maxComments": 0, "authorData": "include"})

QWORD = r"^(how|why|what|which|where|when|can|could|does|do|did|is|are|should|will|would|has|have)(?![\w'’])"

def is_question(text):
    for s in re.split(r"(?<=[.!?])\s+|\n+", text):
        s = s.strip()
        if len(s.split()) >= 4 and (s.endswith("?") or (re.match(QWORD, s, re.I) and not s.endswith((".", "!")))):
            return True
    return False

tops, replies, failed = {}, defaultdict(list), []
for c in client.dataset(run["defaultDatasetId"]).iterate_items():
    if not c["success"]:
        failed.append(f'{c["input"]}: {c["errorType"]}')
    elif c["isReply"]:
        replies[c["parentCommentId"]].append(c)
    else:
        tops[c["commentId"]] = c

ours = lambda c: c["isByVideoOwner"] or c["authorChannelId"] in TEAM
now = datetime.now(timezone.utc)
queue = []
for cid, t in tops.items():
    if ours(t) or not is_question(t["text"]):
        continue
    thread = replies[cid]
    if any(ours(r) for r in thread):
        continue
    status = "unanswered" if len(thread) >= (t["replyCount"] or 0) else "unknown"
    age = (now - datetime.fromisoformat(t["publishedAt"].replace("Z", "+00:00"))).days
    viewers = len({r["authorChannelId"] for r in thread})
    queue.append({
        "status": status, "score": t["likeCount"] + 2 * viewers, "likes": t["likeCount"],
        "viewer_replies": viewers, "age_days": age, "video": t["videoTitle"],
        "question": " ".join(t["text"].split())[:300], "link": t["commentUrl"],
    })

queue.sort(key=lambda q: (q["status"] != "unanswered", -q["score"], -q["age_days"]))
with open("unanswered.csv", "w", newline="", encoding="utf-8") as f:
    w = csv.DictWriter(f, fieldnames=list(queue[0]) if queue else ["status"])
    w.writeheader()
    w.writerows(queue)
print(f"{sum(q['status'] == 'unanswered' for q in queue)} unanswered, "
      f"{sum(q['status'] == 'unknown' for q in queue)} unknown, {len(failed)} videos not read")

How the ranking works:

Likes, because a like on a question means "I want to know too".
Distinct viewers in the thread, weighted double, because people who reply are usually stuck on the same thing or guessing at the answer.
Older first among equals. A question that has waited three weeks should not lose to one posted an hour ago.

To find a teammate's channel ID, open one of their replies in a run's output and copy authorChannelId, or take it from their channel URL if it has the /channel/UC... form.

Working the queue

Open unanswered.csv in a sheet once a week and sort by status and score (the file already is).
Click each link. It opens the video with the comment highlighted, and you reply there. The Actor only reads; it never posts.
When the same question shows up under several videos, answer it once properly: a pinned comment, a line in the description, or the next video.
Spot-check "unknown" rows. They are rare with maxComments: 0, and usually mean a thread grew while the run was reading it, or YouTube still counts a reply it no longer shows.

Schedule it with cron or a CI scheduler, or save the input as a task in Apify Console and add a weekly schedule there, then run the script against the task's latest dataset.

Cost and limits

Price. $0.0004 per delivered comment or reply ($0.40 per 1,000). A channel that gets 2,000 comments and replies a month costs $0.80 per weekly run of the 30-day window. A shorter window costs less, but older questions drop out of the queue unless you carry them over in a file between runs. Failures, comments-off videos and quota errors are free, and a run stops at the maximum cost you set.
Quota and your own key. The built-in API key's 10,000-unit daily quota is shared by all users of the Actor; one unit returns a page of up to 100 comments or replies. A scheduled job should not depend on other people's usage, so create a free key in the Google Cloud Console and pass it as apiKey. When a quota runs out, the run stops cleanly and the remaining videos come back as free rate-limited records.
Held comments are invisible. Comments held for review in YouTube Studio are not public, so they are not in the queue. Check Studio's held tab separately.
Question detection is a rule. It misses questions without a question mark that start with "I can't get...", and it catches some rhetorical ones. Add your own patterns if your viewers phrase problems as statements.

The queue lists your viewers' comments with links, which is what you need to reply. Keep it inside the team, and don't export names you don't need.

If this saves you time, a review on the Store page helps other people find it, and a star on GitHub helps too.

Disclosure: I built this Actor. Source: github.com/josh99smith/youtube-comments-scraper. YouTube is a trademark of Google; the Actor is not affiliated with Google.

Build a YouTube comment dataset for training or evaluating a text classifier, without leaking test data

Joshua Smith — Mon, 26 Oct 2026 13:12:35 +0000

YouTube comments are a good source of short, informal, real-world text for spam, toxicity, intent or sentiment classifiers. They are also an easy way to build a dataset that looks great in evaluation and fails in production: one viral video dominates it, the same copy-pasted comment ends up in train and test, and a model learns the video instead of the label. This post builds the dataset carefully: sampling, pseudonymised authors, de-duplication, a split by video, and a check that your labels mean something.

Decide what the dataset is for

Write down the task and the population before collecting anything:

The label set, with one example and one counter-example for each label. "Spam: promotes a link or channel unrelated to the video" is a definition; "spam: bad comments" is not.
Where the classifier will run. Comments on your own channel, comments in one language, comments on gaming videos? The dataset should look like that, not like YouTube in general.
The test set's job. If the model has to work on channels it has never seen, the test set must come from channels the training set does not include.

Sampling: many videos, a small cap each

Comment counts are extremely skewed. One video can have more comments than a hundred others together, so "collect everything" gives you a dataset about that video. Instead:

Many videos, a fixed cap per video. For example 100-200 comments from each of a few hundred videos across many channels.
Mix the ordering. sortBy: "relevance" (YouTube's "Top comments") over-represents popular, well-written comments. sortBy: "time" gives you the recent, unfiltered stream, including the spam and low-effort comments a spam classifier needs to see. Collect both and record which one each row came from.
Decide about replies. Replies are conversational and often meaningless without their parent. Leave includeReplies off unless the task is about threads, and remember that replies count toward the per-video cap.

Best Damn YouTube Comments Scraper reads comments through the official YouTube Data API v3. One run per ordering:

{
    "startUrls": ["https://www.youtube.com/watch?v=VIDEO_ID_1", "https://www.youtube.com/@SomeChannel"],
    "maxVideosPerChannel": 10,
    "sortBy": "time",
    "maxComments": 150,
    "authorData": "hash"
}

To get a few hundred videos across channels in your domain, use Best Damn YouTube Scraper in search mode, or list the channels you care about.

Pseudonymise authors from the start

authorData: "hash" replaces each commenter's channel ID with a 16-character hash and drops the name, channel URL and avatar. The hash is stable across your runs, so you can still keep one person's comments on one side of the split and cap how many comments one prolific person contributes. It is not reversible on its own, but anyone who knows a candidate channel ID and the salt could test for a match, so treat it as pseudonymous, not anonymous. With "omit" all author fields are removed.

Commenter names are useless as features and risky as data. A model trained on names learns who someone is, not what they wrote. Don't collect what you don't need.

Clean, de-duplicate and split

The script below combines both runs, drops failures and the creator's own comments, removes exact and normalised duplicates, caps comments per author, and assigns each video to train, validation or test with a hash of its videoId. Every comment of a video lands in the same split, so near-identical comments in one thread can't leak across.

import hashlib, json, re
from collections import Counter
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
VIDEOS = ["https://www.youtube.com/watch?v=VIDEO_ID_1", "https://www.youtube.com/@SomeChannel"]
MAX_PER_AUTHOR = 5

rows, seen, per_author = [], set(), Counter()
for order in ("relevance", "time"):
    run = client.actor("josh99smith/youtube-comments-scraper").call(run_input={
        "startUrls": VIDEOS, "maxVideosPerChannel": 10, "sortBy": order,
        "maxComments": 150, "authorData": "hash"})
    for c in client.dataset(run["defaultDatasetId"]).iterate_items():
        if not c["success"] or c["isByVideoOwner"]:
            continue
        norm = re.sub(r"\s+", " ", re.sub(r"https?://\S+", "<url>", c["text"].lower())).strip()
        if len(norm) < 3 or c["commentId"] in seen or norm in seen:
            continue
        if per_author[c["authorChannelId"]] >= MAX_PER_AUTHOR:
            continue
        seen.update([c["commentId"], norm])
        per_author[c["authorChannelId"]] += 1
        rows.append({
            "id": c["commentId"], "video_id": c["videoId"], "channel_id": c["videoChannelId"],
            "author": c["authorChannelId"], "text": c["text"], "likes": c["likeCount"],
            "is_reply": c["isReply"], "published_at": c["publishedAt"], "order": order, "label": None,
        })

def split_for(key, val=0.1, test=0.1):
    bucket = int(hashlib.sha256(key.encode()).hexdigest(), 16) % 1000 / 1000
    return "test" if bucket < test else "val" if bucket < test + val else "train"

for r in rows:
    r["split"] = split_for(r["video_id"])  # use r["channel_id"] to test on unseen channels

with open("comments.jsonl", "w", encoding="utf-8") as f:
    for r in rows:
        f.write(json.dumps(r, ensure_ascii=False) + "\n")
print(len(rows), Counter(r["split"] for r in rows), Counter(r["order"] for r in rows))

Choices worth explaining:

Duplicates are matched on normalised text, with links replaced by <url>, so the same spam posted with different links counts once. Duplicates you remove are useful in their own right: a text that appears under many videos is almost always spam, which makes it a cheap, high-precision label.
The author cap stops one person's 200 comments from teaching the model their style.
Splitting by hash is deterministic: rerun the script with more videos and the old videos stay in the split they were in, so your test set does not quietly change.
Splitting by channel is the stricter option. Comments on one channel share vocabulary, in-jokes and spam campaigns, so a by-video split can still be optimistic.
Emoji, casing and typos are kept in text. They carry signal for tone and spam, and a model in production will see them.

Label, then check the labels

Label a few hundred rows before labelling thousands. Have two people label the same 200 rows independently, then measure agreement. Cohen's kappa corrects for agreement by chance:

def cohen_kappa(a, b):
    labels = set(a) | set(b)
    n = len(a)
    observed = sum(x == y for x, y in zip(a, b)) / n
    expected = sum((a.count(l) / n) * (b.count(l) / n) for l in labels)
    return (observed - expected) / (1 - expected) if expected < 1 else 1.0

Low agreement means the label definitions are ambiguous, not that the labellers are careless. Read the disagreements, rewrite the definitions, and label again. If two people can't agree on whether a comment is sarcastic, a model trained on one person's labels will learn that person, and its test accuracy measures agreement with them.

For an LLM-labelled dataset the same check applies: compare the model's labels with a human-labelled sample before trusting them.

Cost and limits

Price. $0.0004 per delivered comment ($0.40 per 1,000). 300 videos at 150 comments in two orderings is at most 90,000 comments, so at most $36, and usually less: many videos have fewer comments than the cap, and the two orderings overlap. Failures, comments-off videos and quota errors are free, and a run stops at the maximum cost you set.
Use your own API key for collection at this size. The Actor's built-in key has a 10,000-unit daily quota shared by every user, and 90,000 comments in pages of up to 100 per video takes well over 1,000 units. Create a free key in the Google Cloud Console, pass it as apiKey, and you get your own 10,000 units a day. When a quota runs out, the run stops cleanly and the remaining videos come back as free rate-limited records.
Public comments only. Held, removed and members-only comments are not returned, so the dataset under-represents the worst content. A moderation classifier trained on it will see more extreme spam in production than in training.

Rules that apply to the data

Comments are personal data under GDPR and similar laws, even pseudonymised, so you need a legitimate purpose and a retention plan. The comments' authors own their text. YouTube's API Services Developer Policies also set rules on storing and using API data, including how long it may be kept. Read them, and get advice if the dataset is going to be published or used commercially. Keep authorData on hash or omit, don't publish raw comment dumps, and delete what you no longer need.

If this saves you time, a review on the Store page helps other people find it, and a star on GitHub helps too.

Disclosure: I built this Actor. Source: github.com/josh99smith/youtube-comments-scraper. YouTube is a trademark of Google; the Actor is not affiliated with Google.

Vet a YouTube creator before you sponsor them: comments per view, reply rate and comment quality

Joshua Smith — Sun, 25 Oct 2026 13:10:09 +0000

A sponsorship is paid for the audience, and the audience is the part a media kit tells you least about. Subscriber counts can be bought, view counts can come from one viral video, and a comment section can be padded with "great video!" from accounts that never watched. This post checks a shortlist of creators with public data before you sign: engagement per view, how often the creator talks to viewers, and how much of the comment section is real conversation.

It starts where the influencer shortlist post in this series ends: you already have a handful of channels that look right on size and topic.

What to measure, and why

From the videos:

Median views on recent uploads ÷ subscribers. Use the median of the last 10-15 uploads, not the average, so one viral video does not carry the number. A large channel whose recent videos reach a small fraction of its subscribers has an audience that has moved on.
Comments and likes per 1,000 views. Engagement relative to reach, so channels of different sizes compare fairly.
Upload frequency. A channel that posts twice a month will not deliver a weekly integration.

From the comments:

Creator reply rate. The share of top comments where the creator replied. Creators who talk to their viewers usually have viewers who listen to them, including during a sponsor segment.
Generic share. Comments of one or two words, emoji-only comments, and the same text posted by different accounts. Some of that is normal. A comment section that is mostly that is a warning sign.
Repeat-commenter concentration. The share of comments written by the ten most active commenters. A small group commenting on everything can be a loyal community or an engagement group; read their comments to tell which.

None of these has a universal "good" threshold. Compare creators against each other, in the same niche and size band.

Step 1: video statistics

Best Damn YouTube Scraper returns each video's views, likes and comment count, plus the channel's subscriber count, through the official YouTube Data API. Give it the channels and take the last 15 uploads:

{
    "startUrls": ["https://www.youtube.com/@CreatorOne", "https://www.youtube.com/@CreatorTwo"],
    "maxResults": 15
}

Step 2: a comment sample with replies

Best Damn YouTube Comments Scraper reads the comments. You need replies on to see whether the creator answered, and isByVideoOwner marks the creator's own comments and replies.

{
    "startUrls": ["https://www.youtube.com/watch?v=RECENT_VIDEO_1", "https://www.youtube.com/watch?v=RECENT_VIDEO_2"],
    "sortBy": "relevance",
    "includeReplies": true,
    "maxComments": 500,
    "authorData": "hash"
}

Replies count toward maxComments, and popular comments can have hundreds of replies. In a test with a 300-comment cap, one video returned just 20 top-level comments; the rest were replies. The script below therefore only judges threads it received in full: it compares the replies delivered with the comment's replyCount. If too few threads are complete, raise maxComments. authorData: "hash" swaps commenter IDs for stable pseudonyms, enough to count repeat commenters without collecting who they are.

Step 3: the scorecard

import re
from collections import Counter, defaultdict
from datetime import datetime
from statistics import median
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
CHANNELS = ["https://www.youtube.com/@CreatorOne", "https://www.youtube.com/@CreatorTwo"]
SAMPLE_VIDEOS = 5  # per channel, for the comment checks

run = client.actor("josh99smith/youtube-scraper").call(run_input={"startUrls": CHANNELS, "maxResults": 15})
videos = defaultdict(list)
for v in client.dataset(run["defaultDatasetId"]).iterate_items():
    if v["success"]:
        videos[v["channelId"]].append(v)

sample = [v["url"] for vs in videos.values()
          for v in sorted(vs, key=lambda v: v["publishedAt"], reverse=True)[:SAMPLE_VIDEOS]]
run = client.actor("josh99smith/youtube-comments-scraper").call(run_input={
    "startUrls": sample, "sortBy": "relevance", "includeReplies": True,
    "maxComments": 500, "authorData": "hash"})
comments = defaultdict(list)
for c in client.dataset(run["defaultDatasetId"]).iterate_items():
    if c["success"]:
        comments[c["videoChannelId"]].append(c)

def is_generic(text):
    t = text.strip()
    return len(re.findall(r"\w+", t)) <= 2  # covers emoji-only and "first!" too

def per_1k(part, whole):
    return round(1000 * part / whole, 1) if whole else None

for channel_id, vs in videos.items():
    subs = vs[0]["channelSubscribers"]
    views = [v["viewCount"] or 0 for v in vs]
    dates = sorted(datetime.fromisoformat(v["publishedAt"].replace("Z", "+00:00")) for v in vs)
    months = max((dates[-1] - dates[0]).days / 30.4, 1)

    cs = comments[channel_id]
    tops = {c["commentId"]: c for c in cs if not c["isReply"]}
    replies = defaultdict(list)
    for c in cs:
        if c["isReply"]:
            replies[c["parentCommentId"]].append(c)
    complete = [t for t in tops.values() if len(replies[t["commentId"]]) >= (t["replyCount"] or 0)]
    answered = [t for t in complete if any(r["isByVideoOwner"] for r in replies[t["commentId"]])]

    audience = [t for t in tops.values() if not t["isByVideoOwner"]]
    texts = Counter(re.sub(r"\W+", " ", t["text"].lower()).strip() for t in audience)
    copied = sum(n for txt, n in texts.items() if n > 1 and len(txt) > 10)
    generic = sum(is_generic(t["text"]) for t in audience) + copied
    authors = Counter(t["authorChannelId"] for t in audience)
    top10 = sum(n for _, n in authors.most_common(10))

    print(f'\n{vs[0]["channelTitle"]}: {subs:,} subscribers, {len(vs)} recent videos')
    print(f"  median views / subscribers: {median(views) / subs:.2f}" if subs else "  subscribers hidden")
    print(f'  comments per 1k views: {per_1k(sum(v["commentCount"] or 0 for v in vs), sum(views))}')
    print(f'  likes per 1k views:    {per_1k(sum(v["likeCount"] or 0 for v in vs), sum(views))}')
    print(f"  uploads per month:     {len(vs) / months:.1f}")
    print(f"  creator reply rate:    {len(answered)}/{len(complete)} complete threads")
    print(f"  generic or copied:     {generic}/{len(audience)} top comments")
    print(f"  top 10 commenters:     {top10}/{len(audience)} top comments")

Some details that matter:

Hidden subscriber counts. Creators can hide them, and the script prints that instead of dividing by zero. Hidden likes or comments show up as null and count as zero here; check the video if a number looks impossible.
The reply rate covers top comments only. The script reads YouTube's "Top comments" order, which is where a creator's replies are most visible. A creator who answers late questions on old videos will look less engaged than they are.
Copied comments are counted when the same text of more than ten characters appears more than once. That catches pasted promotions and bot rings, and also the occasional popular meme. Read a few before you conclude anything.

Read the comments, not just the numbers

Open ten top comments per creator. You are looking for comments that refer to something specific in the video, viewers answering each other, and the creator's tone when they reply. A channel with ordinary numbers and a comment section where people talk about the content is usually a better buy than one with great numbers and nothing but emoji.

What this cannot tell you: audience country, age, or how many viewers watched the sponsor segment. Those are in the creator's YouTube Studio analytics, which only the creator can see. Ask for a screenshot of the audience tab and recent retention graphs. The checks here tell you whether that screenshot is plausible.

Cost and limits

Price. Videos cost $0.001 each, so 15 videos for each of 10 creators is $0.15. Comments cost $0.0004 each; 5 sample videos for each of 10 creators, capped at 500 comments, is at most 25,000 comments, so at most $10. Lower maxComments or SAMPLE_VIDEOS for a first pass. Failures, comments-off videos and quota errors are free, and a run stops at the maximum cost you set.
Quota. Both Actors use a built-in API key by default whose 10,000-unit daily quota is shared by all users. Reading videos and comments is cheap in quota (about one unit per 50 videos, one unit per page of 100 comments). If you vet creators every week, a free key of your own from the Google Cloud Console, passed as apiKey, keeps you independent of other users. When a quota runs out, runs stop cleanly and the rest come back as free rate-limited records.
Public data only. No login, no Studio analytics, nothing members-only.

Comments are personal data under GDPR and similar laws. Keep authorData on hash, judge the comment section in aggregate, and don't contact or profile individual commenters.

If this saves you time, a review on the Store page helps other people find it, and a star on GitHub helps too.

Disclosure: I built both Actors. Source: github.com/josh99smith/youtube-comments-scraper and github.com/josh99smith/youtube-scraper. YouTube is a trademark of Google; the Actors are not affiliated with Google.

Find your next video ideas in the questions viewers ask under the top videos in your niche

Joshua Smith — Sat, 24 Oct 2026 13:45:53 +0000

The comments under the most-watched videos on a topic are full of questions the video did not answer. Each one is a viewer telling you what they searched for next. This post turns those comments into a ranked list of questions: find the videos, collect their top comments, pull out the questions, group them by subject, and count how many different people asked.

Which videos to read

You want videos where the audience is the audience you want to reach:

The most-viewed videos on the topic, not only the newest. They have the most comments and they define what people already know.
Beginner and how-to videos, where people get stuck and ask.
Your competitors' most popular uploads, if you have specific rivals.

Ten to twenty videos is enough to see patterns. More videos from the same three creators adds less than a few videos from different ones.

Step 1: find the videos

Best Damn YouTube Scraper can search YouTube and return each video's views and comment count. Sort by view count:

{
    "searchQueries": ["sourdough starter"],
    "searchOrder": "viewCount",
    "maxResults": 15
}

Drop videos with a low commentCount: there is nothing to read. Search is the expensive part of the YouTube API, 100 quota units per search page, so if you run many searches use your own API key (see Cost and limits).

Step 2: collect top comments, without replies

Best Damn YouTube Comments Scraper reads comments through the official YouTube Data API v3. Two settings matter for questions:

sortBy: "relevance" returns YouTube's "Top comments" order, so the comments other viewers liked come first. A cap of a few hundred per video keeps the ones that resonated.
Leave replies off. Replies count toward the per-video cap. In a test with a 300-comment cap and replies on, one video returned only 20 top-level comments; the other 280 were replies to them. Replies are where people answer each other, not where new questions are asked.

{
    "startUrls": ["https://www.youtube.com/watch?v=VIDEO_ID_1", "https://www.youtube.com/watch?v=VIDEO_ID_2"],
    "sortBy": "relevance",
    "maxComments": 300,
    "authorData": "hash"
}

authorData: "hash" replaces each commenter's channel ID with a stable pseudonym and drops names. You can still count distinct people without knowing who they are.

Step 3: extract, group and rank the questions

A comment counts as a question if a sentence ends in ? or starts with a question word. Short ones ("why?", "what??") are dropped; they react to the video rather than ask about the topic. Plurals are folded crudely, so starters and starter count as one word. Grouping uses the most common topic words across all questions: each question goes to the most frequent word it contains. That is crude, but it needs no extra libraries, and it is easy to see why a question landed where it did.

import re
from collections import Counter, defaultdict
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

search = client.actor("josh99smith/youtube-scraper").call(run_input={
    "searchQueries": ["sourdough starter"], "searchOrder": "viewCount", "maxResults": 15})
videos = [v["url"] for v in client.dataset(search["defaultDatasetId"]).iterate_items()
          if v["success"] and (v["commentCount"] or 0) >= 50]

run = client.actor("josh99smith/youtube-comments-scraper").call(run_input={
    "startUrls": videos, "sortBy": "relevance", "maxComments": 300, "authorData": "hash"})

QWORD = r"^(how|why|what|which|where|when|can|could|does|do|did|is|are|should|will|would|has|have)(?![\w'’])"
STOP = set("""a an the and or but if so to of in on at for with from by about as is are was were be been
do does did can could should would will has have had i you he she it we they me my your our their this that
these those there here what which who whom whose how why where when not no yes just also than then too very
any some more most much many get got make use using one way still really video thanks thank please
can't don't doesn't isn't into like time know think anyone someone people guys his her him them its""".split())

def questions(text):
    for s in re.split(r"(?<=[.!?])\s+|\n+", text):
        s = s.strip()
        if len(s.split()) >= 4 and (s.endswith("?") or (re.match(QWORD, s, re.I) and not s.endswith((".", "!")))):
            yield s

def words(s):
    ws = set(re.findall(r"[a-z][a-z'’-]{2,}", s.lower())) - STOP
    return {w[:-1] if len(w) > 4 and w.endswith("s") and not w.endswith("ss") else w for w in ws}

found, seen = [], set()
for c in client.dataset(run["defaultDatasetId"]).iterate_items():
    if c["success"] and not c["isByVideoOwner"]:
        for q in questions(c["text"]):
            key = re.sub(r"\W+", " ", q.lower()).strip()
            if key not in seen:  # copy-pasted questions count once
                seen.add(key)
                found.append((q, words(q), c))

freq = Counter(w for _, ws, _ in found for w in ws)
groups = defaultdict(lambda: {"people": set(), "likes": 0, "examples": []})
for q, ws, c in found:
    topic = max(ws, key=lambda w: (freq[w], w)) if ws else "(other)"
    g = groups[topic]
    g["people"].add(c["authorChannelId"])
    g["likes"] += c["likeCount"]
    g["examples"].append((c["likeCount"], q, c["commentUrl"]))

ranked = sorted(groups.items(), key=lambda kv: (-len(kv[1]["people"]), -kv[1]["likes"]))
for topic, g in ranked[:15]:
    print(f"\n{topic}: {len(g['people'])} people, {g['likes']} likes")
    for likes, q, url in sorted(g["examples"], reverse=True)[:3]:
        print(f"  [{likes}] {q[:140]}  {url}")

Add words that appear in every comment for your topic (for example sourdough, starter) to STOP, or every question lands in one group. When the groups get too coarse, embed each question with any sentence-embedding model and cluster the vectors instead; the counting and ranking stay the same.

Read the list before you plan videos

Rank by distinct people, then likes. Ten people asking the same thing is a stronger signal than one question with many likes, and likes are how other viewers say "me too" without writing.
Read the top examples in each group. Keyword rules cannot tell a sincere question from a joke, and some questions are rhetorical ("who else is here in 2026?"). Those are easy to spot and drop by hand.
Check whether a video already answers it. Search your topic plus the question words on YouTube. A question asked under a popular video and still unanswered elsewhere is the best candidate.
Note the wording. The way viewers phrase a question is often close to what they type into search, which makes it a good starting point for a title.

Cost and limits

Price. Comments cost $0.0004 each ($0.40 per 1,000). Fifteen videos capped at 300 comments is at most 4,500 comments, so at most $1.80. The video search costs $0.001 per video, $0.015 for 15. Unreadable videos, comments-off videos and quota errors are free, and a run stops at the maximum cost you set.
Quota and your own key. Both Actors use a built-in API key by default, and its 10,000-unit daily quota is shared by every user. Comments are cheap in quota (one unit per page of up to 100), but each search page costs 100 units. If you search more than a handful of terms, create a free key in the Google Cloud Console and pass it as apiKey to both Actors. You get your own 10,000 units a day, and you don't take quota from other users. When a quota runs out, runs stop cleanly and the remaining inputs come back as free rate-limited records.
Top comments are YouTube's ordering. It is not documented and not purely by likes. For a topic where recent questions matter, also run sortBy: "time" with publishedAfter: "3 months".
Public data only. No login, nothing members-only.

Comments are personal data under GDPR and similar laws. Work with grouped questions, not people. Keep authorData on hash or omit, and leave names out if you quote a question.

If this saves you time, a review on the Store page helps other people find it, and a star on GitHub helps too.

Disclosure: I built both Actors. Source: github.com/josh99smith/youtube-comments-scraper. YouTube is a trademark of Google; the Actors are not affiliated with Google.

A daily digest of new YouTube comments in Slack, without paying for comments you already saw

Joshua Smith — Fri, 23 Oct 2026 14:53:43 +0000

YouTube Studio tells you about comments one at a time, and only on your own channel. A team that wants to see what viewers said yesterday, on its own videos or a competitor's, needs a daily list in the place it already reads. This post builds that list: a scheduled run that collects only new comments, a small state file so nothing is posted twice, and a Slack message with the comments worth reading first.

What a useful digest contains

Only new comments. Yesterday's comments on recent videos, not every comment again.
Grouped by video, with the video title, so people know what each comment refers to.
Ranked by likes within each video. A liked comment is one other viewers agreed with.
A link to each comment. Replying happens on YouTube, so one click should open the comment in place.
No comments by the channel itself. The creator's own replies are not audience feedback.

Why "newest first" plus a date keeps it cheap

Best Damn YouTube Comments Scraper is an Apify Actor that reads comments through the official YouTube Data API v3. Given a channel URL, it reads the channel's most recent uploads. Two options do most of the work here:

sortBy: "time" asks YouTube for comments newest first.
publishedAfter: "1 day" skips anything older, and with newest-first order the Actor stops paging as soon as it reaches an older comment.

So a video that got no comments yesterday costs one API page and nothing on your bill. In a test run on the five latest uploads of a large tech channel, two videos had nothing new and returned zero comments, and the whole run delivered 1,177 comments using 19 quota units.

The Actor ships with a saved task for exactly this input:

{
    "startUrls": ["https://www.youtube.com/@YourChannel"],
    "maxVideosPerChannel": 5,
    "sortBy": "time",
    "publishedAfter": "1 day",
    "maxComments": 0
}

maxComments: 0 means no per-video cap, which is safe here because the date filter is the real limit. Add competitor channels to startUrls to watch them in the same run.

The gap to know about: only the newest maxVideosPerChannel uploads are read. A comment on a video from last year is not in the digest. Raise the number if your back catalogue still gets comments, or run a weekly job with a larger value and publishedAfter: "7 days".

Overlap the window, then de-duplicate

A schedule never fires at exactly the same second each day, and the API can show a comment a little late. A strict 24-hour window loses comments at the edges. Use publishedAfter: "2 days" and keep a file of comment IDs you have already posted. The overlap means about one extra day of comments per run, so on a busy channel it roughly doubles the comments you pay for; on a quiet one the difference is pennies.

The script

It runs the Actor, drops comments it has already reported, groups the rest by video and posts the top five per video to a Slack incoming webhook.

import json, os, urllib.request
from collections import defaultdict
from pathlib import Path
from apify_client import ApifyClient

STATE = Path("seen_comments.json")
TOP_PER_VIDEO = 5

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("josh99smith/youtube-comments-scraper").call(run_input={
    "startUrls": ["https://www.youtube.com/@YourChannel"],
    "maxVideosPerChannel": 5,
    "sortBy": "time",
    "publishedAfter": "2 days",
    "maxComments": 0,
    "authorData": "omit",
})

seen = set(json.loads(STATE.read_text())) if STATE.exists() else set()
by_video, failed = defaultdict(list), []
for c in client.dataset(run["defaultDatasetId"]).iterate_items():
    if not c["success"]:
        failed.append(f'{c["input"]}: {c["errorType"]}')
    elif c["commentId"] not in seen and not c["isByVideoOwner"]:
        by_video[(c["videoId"], c["videoTitle"])].append(c)

def clip(text, n=200):
    text = " ".join(text.split())
    text = text if len(text) <= n else text[: n - 1] + "…"
    # Slack treats &, < and > as markup, and | ends the link text
    return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace("|", "¦")

lines = []
for (video_id, title), comments in sorted(by_video.items(), key=lambda kv: -len(kv[1])):
    lines.append(f"*<https://www.youtube.com/watch?v={video_id}|{clip(title, 100)}>*: {len(comments)} new")
    for c in sorted(comments, key=lambda c: -c["likeCount"])[:TOP_PER_VIDEO]:
        lines.append(f'• {c["likeCount"]} likes: <{c["commentUrl"]}|{clip(c["text"])}>')
if failed:
    lines.append("Not read: " + ", ".join(failed))

if lines:
    body = json.dumps({"text": "\n".join(lines)}).encode()
    req = urllib.request.Request(os.environ["SLACK_WEBHOOK_URL"], body, {"Content-Type": "application/json"})
    urllib.request.urlopen(req)

seen |= {c["commentId"] for cs in by_video.values() for c in cs}
STATE.write_text(json.dumps(sorted(seen)))

Notes on the choices:

authorData: "omit" leaves out commenter names and channels. A digest is about what was said, and the link opens the comment if someone needs to reply. Use "include" only if your team really needs names in Slack.
The state file keeps growing. Trim it to the last few thousand IDs, or store publishedAt with each ID and drop anything older than the window.
Slack truncates very long messages. On a busy channel, post one message per video, or lower TOP_PER_VIDEO and link the run's dataset in Apify Console instead.
Failures are listed, not hidden. A video with comments turned off comes back as a free comments-disabled record.

Scheduling it

Two options:

Run the script from cron or a CI scheduler (GitHub Actions schedule: works) every morning. The state file needs to persist between runs, so commit it or keep it in a cache or bucket.
No code: in Apify Console, open the Actor's "Monitor new comments on a YouTube channel daily" task, change the channel, and add a schedule (Schedules, then a cron such as 0 7 * * *). Add the Slack integration on the task to get a message when a run finishes, and open the dataset from there. You lose the de-duplication and ranking, but it takes two minutes.

Watching mentions on videos you do not own

For a brand, the interesting comments are often on other people's reviews. Put those video URLs in startUrls and set searchTerms to your brand name. That uses YouTube's own comment search, so you pay only for matches. It searches top-level comments only, and it is YouTube's search, not exact substring matching, so check a sample before you trust it. The product-feedback post in this series covers that filtering in more detail.

Cost and limits

Price. $0.0004 per delivered comment or reply ($0.40 per 1,000). The test run above, 1,177 comments, would cost $0.47. A quiet channel with 50 new comments a day costs about $0.04 a day with the two-day window. Failures, videos with comments off and quota errors are free, and a run never goes past the maximum cost you set.
Use your own API key for a scheduled job. By default the Actor uses a built-in key whose 10,000-unit daily quota is shared by every user. One unit returns a page of up to 100 comments, so a digest like this uses little, but a schedule that runs every day is exactly the kind of job that should not depend on other people's usage. A free key from the Google Cloud Console, pasted into apiKey, gives you your own 10,000 units. If a quota does run out, the run stops cleanly, the remaining videos come back as free rate-limited records, and the quota resets at midnight Pacific Time.
Comments can appear late. YouTube holds some comments for review, and those only show up once approved. The two-day window catches most of them.
Public data only. No login, so nothing members-only and nothing from YouTube Studio's held-for-review queue.

If this saves you time, a review on the Store page helps other people find it, and a star on GitHub helps too.

Disclosure: I built this Actor. Source: github.com/josh99smith/youtube-comments-scraper. YouTube is a trademark of Google; the Actor is not affiliated with Google.

Core Web Vitals field data vs lab data: why a Lighthouse 100 can still fail

Joshua Smith — Sun, 18 Oct 2026 13:09:38 +0000

A page scores 100 in Lighthouse, and Search Console's Core Web Vitals report still flags it as failing. Both are right: they measure different things. Here is why they disagree, and a script that sorts a URL list so you fix what Google measures first.

Lab data and field data

Lab data is one simulated load by Lighthouse on Google's test device. It is good for debugging, though scores vary a few points between runs.

Field data comes from the Chrome UX Report (CrUX): real Chrome users, a trailing 28-day window, reported at the 75th percentile, so three in four visits were at least that good.

Thresholds from web.dev's Web Vitals guidance, judged at the 75th percentile:

LCP (loading): good at 2.5 seconds or less, poor above 4 seconds.
INP (responsiveness): good at 200 ms or less, poor above 500 ms.
CLS (visual stability): good at 0.1 or less, poor above 0.25.

In between is "needs improvement". The PageSpeed Insights API names the buckets FAST, AVERAGE and SLOW. A page passes when all three metrics are good.

Why a page can score 100 in the lab and still fail

The lab run is one device, one connection, one visit:

INP cannot be measured in the lab: a Lighthouse load has no user to tap anything. web.dev names Total Blocking Time as the lab stand-in, which is only a proxy.
Real devices are slower and more varied, and the 75th percentile is the slow end of your audience.
Layout shift continues after load: late ads, consent banners, lazy images. A lab run does not scroll or wait around.
Real visits differ: warm caches, logged-in views, A/B variants, other countries.
Field data covers 28 days, so a fix shipped yesterday barely moves it.

It works in reverse too: a page scoring 60 in the lab can pass in the field. That is a lab-only problem, second in the queue.

Page-level data or origin fallback

PageSpeed Insights uses data for the exact URL first. With too few real-user samples it falls back to origin-level data, the combined numbers for the whole site. If the origin has too little as well, there is no field data. The Actor below exposes which level you got as fieldData.originFallback.

originFallback: false: the numbers describe this page.
originFallback: true: origin-level numbers, identical for every page of that origin that fell back.
fieldData: null: no usable field data, lab numbers only.

Ten pages failing on fallback are one finding about the site (shared templates, scripts, banners), not ten about pages. A page-level failure is the strongest evidence, so it goes first.

Get both kinds of data for a list of URLs

The PageSpeed Insights API v5 returns both blocks, one URL and one device per call, each taking Google roughly 10 to 30 seconds. A list needs concurrency, retries and quota handling. PageSpeed Insights Audit is an open-source Apify Actor that runs that loop and returns one flat record per URL and strategy.

{
    "urls": ["https://example.com/", "https://example.com/pricing", "https://example.com/blog/post"],
    "strategy": "mobile",
    "categories": ["performance"],
    "includeAuditDetails": true
}

Mobile is the strategy Google Search ranks on; includeAuditDetails adds opportunities. Save as input.json:

curl -X POST "https://api.apify.com/v2/acts/josh99smith~pagespeed-insights-audit/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d @input.json -o results.json

For long lists (about 10 minutes per 100 URLs) use the apify-client packages.

A triage script: field failures first

The script calls a page failing when fieldData.lcpMs, inpMs or cls has a category other than FAST, and skips metrics with no data.

import { readFileSync } from "node:fs";

const rows = JSON.parse(readFileSync(process.argv[2], "utf8"));
const bad = (r) =>
  ["lcpMs", "inpMs", "cls"].filter((k) => {
    const c = r.fieldData?.[k]?.category;
    return c && c !== "FAST";
  });
const sev = (r) => bad(r).reduce((n, k) => n + (r.fieldData[k].category === "SLOW" ? 2 : 1), 0);
const why = (r) =>
  bad(r).map((k) => `${k.replace("Ms", "")} ${r.fieldData[k].percentile} ${r.fieldData[k].category}`).join(", ");
const show = (title, list, fn) => {
  console.log(`\n${title} (${list.length})`);
  list.forEach((r) => console.log(`  ${r.strategy} ${fn(r)}`));
};

const ok = rows.filter((r) => r.success);
const failing = ok.filter((r) => bad(r).length).sort((a, b) => sev(b) - sev(a));
const pageLevel = failing.filter((r) => !r.fieldData.originFallback);
const originLevel = [
  ...new Map(
    failing.filter((r) => r.fieldData.originFallback).map((r) => [r.strategy + new URL(r.url).origin, r])
  ).values(),
];
const labOnly = ok
  .filter((r) => !bad(r).length && (r.scores?.performance ?? 100) < 90)
  .sort((a, b) => a.scores.performance - b.scores.performance);

show("1. FAILING IN FIELD DATA, page level", pageLevel, (r) =>
  `${r.url} ${why(r)} | top fix: ${r.opportunities?.[0]?.title ?? "n/a"}`);
show("2. FAILING AT ORIGIN LEVEL", originLevel, (r) => `${new URL(r.url).origin} ${why(r)}`);
show("3. LAB ONLY", labOnly, (r) =>
  `${r.url} perf ${r.scores.performance}, ${r.fieldData ? "field passes" : "no field data"}`);

const failed = rows.filter((r) => !r.success);
console.log(`\nNot audited (free): ${failed.length} ${failed.map((r) => r.errorType).join(" ")}`);

Run node triage.mjs results.json. List 1: page-level field failures, most severe first, with the largest lab opportunity as a lead (a lab estimate). List 2: origin-level failures, one row per origin and device. List 3: lab-only, no field failure and performance below 90 (90+ counts as good).

For INP and CLS, which the lab barely sees, Google's web-vitals library on your pages shows the interaction or element behind a field number.

Cost and limits

The price is $0.004 per successfully audited URL and strategy. Assuming 150 URLs and every audit succeeds:

Mobile only: 150 audits, $0.60 per run.
Mobile and desktop: 300 audits, $1.20 per run.

Failed audits cost nothing and a run stops at the maximum cost you set. Limits:

Field data needs real traffic: low-traffic pages return fieldData: null or origin-level numbers.
Lab scores vary by a few points between runs; compare moving averages.
The default Google API key and its daily quota are shared. When it runs out you get free rate-limited records; your own free key in apiKey gives a dedicated 25,000 audits per day.
Google must fetch the page: logins, non-public staging and localhost fail with http-error. Failures return success: false and are unbilled.

If this saves you time, a review on the Store page helps other people find it, and a star on GitHub helps too.

Disclosure: I built this Actor. Source: github.com/josh99smith/pagespeed-insights-audit. PageSpeed Insights and Lighthouse are Google trademarks; the Actor is not affiliated with Google.

How to benchmark your PageSpeed and Core Web Vitals against five competitors

Joshua Smith — Sat, 17 Oct 2026 13:10:07 +0000

Everyone has an opinion on whether their site beats the competition's. Few people have the table. A fair benchmark is easy to get wrong: comparing your home page with a rival's blog post, mixing real-user data with lab data, or ranking a rival with no data as if it came last. Below are the method, a script that ranks the results, and the Actor that produces them. Public pages and public data only.

Pick pages you can compare fairly

Choose three page types and use the same three for every site: the home page, the product or pricing page, and one blog post. They are built differently: a home page is mostly layout and images, a pricing page may load analytics and a chat widget, an article is mostly text. Comparing across types tells you little, and a site can lead on one page type while trailing on another.

For the blog post, pick one of similar length and format on each site, and skip posts built around a video player or heavy embed.

Run every page on mobile and desktop. Google Search ranks with mobile data, but your customers may mostly use desktop, and a rival can lead on one and trail on the other.

Use field data first, lab data to fill the gaps

Each audit returns two kinds of numbers.

Lab data is one Lighthouse run on a Google test device: the performance score (0 to 100) and metrics such as LCP, CLS and TBT. It exists for any page Google can load, but two runs of the same page can differ by a few points.

Field data is what real Chrome users experienced, as the 75th percentile over 28 days, for LCP, INP, CLS, FCP and TTFB. Google only has it for pages or sites with enough traffic; otherwise fieldData is null and you get lab data only.

Keep them in separate tables: lead with field data where it exists, use lab data so every page appears, and never blend them into one score. Where they disagree, fix field data first, as the README advises.

Rank fairly when rivals have no field data

Smaller rivals often have no field data. Set the rules before you look at the numbers:

Missing is not zero and not worst. Leave it out of the ranking and show n/a.
Rank a site only against others with data for the same page type and metric, and write 2/4, not 2. Second of four and second of six are different claims.
To combine page types, average rank / n, not raw ranks.
Treat origin-level data separately. When fieldData.originFallback is true, the numbers are origin-level, meaning the whole site rather than that page, so the script leaves them unranked.
Make the lab tables your headline, since every audited page appears in them, and say how many rivals each field table covers.

A row full of n/a is a statement about traffic, not about speed.

Run the audits

Six sites, three pages each and two strategies make 36 audits. PageSpeed Insights Audit is an open-source Apify Actor that calls Google's official PageSpeed Insights API and returns one record per URL and strategy, so you skip the request loop and the raw report. Paste the pages into Page URLs, set Device strategy to Both and click Start, or send this input (placeholder domains):

{
    "urls": [
        "https://yoursite.example/",
        "https://yoursite.example/pricing",
        "https://yoursite.example/blog/how-we-do-x",
        "https://competitor-a.example/",
        "https://competitor-a.example/plans",
        "https://competitor-a.example/blog/guide-to-x",
        "https://competitor-b.example/",
        "https://competitor-b.example/pricing",
        "https://competitor-b.example/blog/x-explained",
        "https://competitor-c.example/",
        "https://competitor-c.example/pricing",
        "https://competitor-c.example/blog/x-tips",
        "https://competitor-d.example/",
        "https://competitor-d.example/plans",
        "https://competitor-d.example/blog/x-checklist",
        "https://competitor-e.example/",
        "https://competitor-e.example/pricing",
        "https://competitor-e.example/blog/x-basics"
    ],
    "strategy": "both",
    "includeAuditDetails": true
}

includeAuditDetails adds the top failing audits to every record. From the API, with the JSON saved as input.json:

curl -X POST "https://api.apify.com/v2/acts/josh99smith~pagespeed-insights-audit/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" -d @input.json -o results.json

The call waits for the run, and synchronous endpoints suit short runs; for a longer list use the apify-client packages.

Rank the results with a script

The script reads results.json, matches each record's url to a site and page type, ranks every metric within a page type, and prints one table per strategy and metric plus a one-paragraph summary. Cells read value (rank/n); rows are sorted by average rank / n. Edit YOU and SITES for your own pages, with the same URLs you sent, since the match is on the url you supplied. Save it as rank.py; it needs Python 3.8 or later and no packages.

import json
import sys
from collections import defaultdict

YOU = "yoursite.example"
KINDS = ("home", "pricing", "blog")
SITES = {  # one path per page type, in the order of KINDS
    "yoursite.example": ("/", "/pricing", "/blog/how-we-do-x"),
    "competitor-a.example": ("/", "/plans", "/blog/guide-to-x"),
    "competitor-b.example": ("/", "/pricing", "/blog/x-explained"),
    "competitor-c.example": ("/", "/pricing", "/blog/x-tips"),
    "competitor-d.example": ("/", "/plans", "/blog/x-checklist"),
    "competitor-e.example": ("/", "/pricing", "/blog/x-basics"),
}
PAGES = {f"https://{s}{p}": (s, k) for s, ps in SITES.items() for k, p in zip(KINDS, ps)}
METRICS = {  # path in the record: is lower better?
    ("scores", "performance"): False,
    ("labMetrics", "lcpMs"): True,
    ("labMetrics", "tbtMs"): True,
    ("fieldData", "lcpMs", "percentile"): True,
    ("fieldData", "inpMs", "percentile"): True,
    ("fieldData", "cls", "percentile"): True,
}


def get(rec, path):
    fd = rec.get("fieldData")
    if path[0] == "fieldData" and (not fd or fd.get("originFallback")):
        return None  # no page-level field data: leave it unranked
    for key in path:
        rec = rec.get(key) if isinstance(rec, dict) else None
    return rec


data, failed = defaultdict(dict), []  # data: (strategy, page type) -> {site: record}
for r in json.load(open(sys.argv[1], encoding="utf-8")):
    if r["url"] in PAGES:
        site, kind = PAGES[r["url"]]
        if r["success"]:
            data[r["strategy"], kind][site] = r
        else:
            failed.append(f"{site} {kind} {r['strategy']}")

mine = defaultdict(list)  # your ranks: (strategy, is field) -> [(metric, page, rank, n)]
for strategy in ("mobile", "desktop"):
    for path, lower in METRICS.items():
        name = ".".join(path[:2])
        rel, shown = defaultdict(list), defaultdict(dict)
        for kind in KINDS:
            vals = {s: v for s, r in data[strategy, kind].items() if (v := get(r, path)) is not None}
            ordered = sorted(vals.values(), reverse=not lower)
            for s, v in vals.items():
                rank = ordered.index(v) + 1  # ties share a rank
                rel[s].append(rank / len(vals))
                shown[s][kind] = f"{v:g} ({rank}/{len(vals)})"
                if s == YOU and len(vals) > 1:
                    mine[strategy, path[0] == "fieldData"].append((name, kind, rank, len(vals)))
        print(f"\n{strategy}: {name}")
        for s in sorted(SITES, key=lambda s: sum(rel[s]) / len(rel[s]) if rel[s] else 9):
            print(f"{s:22}", *(shown[s].get(k, "n/a") for k in KINDS), sep=" | ")

parts = []
for (strategy, field), c in mine.items():
    pos = lambda x: (x[2] - 1) / (x[3] - 1)
    best, worst = min(c, key=pos), max(c, key=pos)
    parts.append(
        f"On {strategy} {'field' if field else 'lab'} data {YOU} is first in {sum(x[2] == 1 for x in c)} "
        f"of {len(c)} comparisons and last in {sum(x[2] == x[3] for x in c)}; strongest is {best[0]} on "
        f"{best[1]}, weakest is {worst[0]} on {worst[1]}."
    )
print("\nSummary:", " ".join(parts), "This is one snapshot, not a verdict.",
      "Not audited:", ", ".join(failed) or "none")

Run python rank.py results.json. Read the lab tables first, then the field tables, noting each n. The summary counts how often you rank first and last, for lab and field separately, and names your strongest and weakest comparison. Lab metrics move together, so the counts are not independent wins. Where you trail, opportunities[] in that page's record lists failing audits with savingsMs.

Cost and limits

The Actor charges a flat $0.004 per successfully audited page and strategy. For 6 sites x 3 pages x 2 strategies that is 36 audits: 36 x $0.004 = $0.144, about 14 cents. If two audits fail you pay for 34, or $0.136. Invalid URLs, pages Google cannot load and quota errors are recorded with success: false and an errorType, and cost nothing. A run also stops at the maximum cost you set.

One run is a snapshot. Rivals ship changes and Lighthouse varies by a few points, so quote the date, and for a steadier answer repeat the benchmark three times and compare medians: 108 audits, $0.432. Four weekly runs are 144 audits, $0.576.

Limits to plan around:

Public pages only. Google must be able to fetch the page, so protected pages fail with http-error.
By default the Actor uses a built-in Google API key shared by all its users: 25,000 requests a day and a few hundred a minute. When the quota runs out you get free rate-limited records; retry later or paste your own free key into Google API key.
Each audit takes Google roughly 10 to 30 seconds, and the README estimates 100 URLs in about 10 minutes, so expect minutes, not hours.

If this saves you time, a review on the Store page helps other people find it, and a star on GitHub helps too.

Disclosure: I built this Actor. Source: github.com/josh99smith/pagespeed-insights-audit. PageSpeed Insights and Lighthouse are Google trademarks; the Actor is not affiliated with Google.

Weekly PageSpeed monitoring in Google Sheets, with an alert that ignores one-off dips

Joshua Smith — Fri, 16 Oct 2026 13:10:42 +0000

A one-off PageSpeed check shows how a page scored today. A weekly one shows when something broke. You need a schedule, a sheet that only grows, and an alert rule that does not fire on noise.

Audit templates, not every URL

Pages built from one template share their code, so one representative page per template speaks for the rest: the home page, a listing page, a detail page, a form or contact page, and any landing page you pay traffic to. A handful per site is enough; auditing every URL multiplies cost and noise, not findings.

Pick fixed URLs ("latest post" changes every week) that Google can fetch publicly. Monitor mobile, which is what Google ranks on, and add desktop only where the audience is mostly desktop. Each device is its own series; never average them.

What each history row needs

The sheet is the history, so every row must describe itself:

fetchedAt: when the row was recorded. Failed rows have it too, so sort on it. analysisTimestamp is when Google ran Lighthouse.
url as you supplied it, strategy, and finalUrl: a changed final URL means a redirect changed and scores may not compare.
success, scores.performance and the other three scores, plus labMetrics to explain drops.
fieldData.overallCategory and lighthouseVersion, to check whether a step change matches a Lighthouse upgrade.

Run on the same weekday and hour with the same input.

An alert rule that survives noise

Lighthouse scores wobble: two runs of the same page can differ by a few points, and some weeks a page fails to load. Alerting on one reading trains you to ignore the alert. Instead:

Alert when a page's two most recent usable readings are both below its threshold.
Set the threshold from data: wait a few weeks, then sit below the normal range by more than the wobble.
A failed audit is no reading, not a 0 or a 100. Alert separately when two runs in a row return nothing for a page.

The price is delay: the alert comes a week after the first bad reading. Too slow? Run twice a week with the same rule.

Run the audits on a schedule

Best Damn PageSpeed Insights Audit calls Google's official PageSpeed Insights API. Save an input like this as a task in your Apify account and give it a weekly schedule, for example the cron expression 0 6 * * 1:

{
    "urls": [
        "https://example.com/",
        "https://example.com/category/shoes",
        "https://example.com/product/sample",
        "https://example.com/contact"
    ],
    "strategy": "mobile",
    "categories": ["performance", "accessibility", "best-practices", "seo"],
    "includeAuditDetails": false
}

Keep includeAuditDetails off so rows stay flat; when an alert fires, re-run a flagged page once with it on to see its top opportunities. Paste your own free Google API key into apiKey for a dedicated 25,000 audits a day. The shared default key can run out and return free rate-limited records, which leave gaps.

From your own cron, one call returns a short list's rows:

curl -X POST "https://api.apify.com/v2/acts/josh99smith~pagespeed-insights-audit/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "urls": ["https://example.com/", "https://example.com/contact"], "strategy": "mobile" }'

Append to a sheet and chart it

The Integrations tab lists Google Sheets, Make, Zapier and n8n. Whichever you use, trigger it when a run succeeds, add rows instead of replacing the sheet, name the tab history, and check that nested fields like scores.performance get their own columns.

For the chart, make a pivot table: fetchedAt grouped by day as rows, url as columns, average scores.performance as values, filtered to one strategy. Insert a line chart; failed audits leave gaps, not zeros. Add a moving-average trendline, as the Actor's README advises for trend reports.

The alert script

Open Extensions, then Apps Script. Paste this, set EMAIL, change COL to your header names (keep the order), and add a weekly time-driven trigger for weeklyCheck a few hours after the Apify schedule. It repeats weekly until the page recovers.

const LIMITS = { '*': 80 };  // placeholder; override: 'https://example.com/heavy (mobile)': 60
const EMAIL = 'you@example.com';
const COL = ['fetchedAt', 'url', 'strategy', 'success', 'scores.performance'];

function findAlerts(values) {
  const ix = COL.map(c => values[0].indexOf(c));
  if (ix.includes(-1)) throw new Error('Missing column');
  const [when, url, dev, success, score] = ix;
  const series = {}, alerts = [];
  for (const r of values.slice(1)) {
    const t = +new Date(r[when]);
    if (!r[url] || isNaN(t)) continue;
    const perf = r[score] === '' ? NaN : Number(r[score]);
    const ok = String(r[success]).toLowerCase() === 'true' && Number.isFinite(perf);
    const key = r[url] + ' (' + r[dev] + ')';
    (series[key] = series[key] || []).push({ t, perf, ok });
  }
  for (const key in series) {
    const rows = series[key].sort((a, b) => b.t - a.t);
    const limit = LIMITS[key] || LIMITS['*'];
    const good = rows.filter(r => r.ok).slice(0, 2);
    if (rows.length > 1 && !rows[0].ok && !rows[1].ok)
      alerts.push(key + ': no reading in the last two runs');
    else if (good.length === 2 && good.every(r => r.perf < limit))
      alerts.push(key + ': ' + good[1].perf + ', then ' + good[0].perf);
  }
  return alerts;
}

function weeklyCheck() {
  const sheet = SpreadsheetApp.getActive().getSheetByName('history');
  const alerts = findAlerts(sheet.getDataRange().getValues());
  if (alerts.length) MailApp.sendEmail(EMAIL, 'PageSpeed alert', alerts.join('\n'));
}

A blank score is skipped, never read as 0.

Cost and limits

The price is $0.004 per successfully audited URL and strategy. Assuming 3 sites with 6 templates each (18 URLs) and every audit succeeds:

Mobile only: 18 audits, $0.072 a week, $3.74 over 52 weeks.
Mobile and desktop: 36 audits, $0.144 a week, $7.49 over 52 weeks.
Twice a week doubles either figure.

Failed audits are free, so these are ceilings. A run stops at the maximum cost you set, so set it just above the weekly figure. Your Apify plan itself is not included.

Limits:

scores.performance is a lab estimate. Real-user fieldData, which the README treats as the Google Search signal, is null for low-traffic pages.
Pages must be public. Staging, localhost and login pages fail with http-error: free, but a gap, not a good score.

If this saves you time, a review on the Store page helps other people find it, and a star on GitHub helps too.

Disclosure: I built this Actor. Source: github.com/josh99smith/pagespeed-insights-audit. PageSpeed Insights and Lighthouse are Google trademarks; the Actor is not affiliated with Google.

Compare PageSpeed Insights before and after a deploy, and fail CI on regressions

Joshua Smith — Thu, 15 Oct 2026 13:10:07 +0000

A release swaps a theme, a plugin or a script bundle, and nobody notices a page got slower until a client says so. Audit the same pages before and after, diff the numbers, and fail the pipeline on a regression. The hard part is defining "worse" when no two Lighthouse runs are identical.

Pick a URL list you can keep

Use one page per template: home, a listing, a detail page, an article, any public funnel step.
Pin specific items (one product, one post). A "latest posts" page changes between runs.
Commit the list. Both runs need the same URLs, device strategy and categories.
Keep it public. Google fetches pages from its own servers, so localhost and pages behind a login fail with http-error. Audit production or a public preview URL.

A pinned list has a blind spot: it cannot cover pages the release adds. Reader @omyvnss pointed this out. To catch them, extract the site's sitemap URLs before and after the release and compare. The Sitemap URL Extractor, which I also built, does the extraction. Add one page for each new kind of URL, such as a new path prefix. This only works if the sitemap updates with the deploy, and extraction is billed per URL ($0.0002), so on a large site it can cost more than the audits themselves.

Lighthouse is noisy, so set a tolerance

Two runs of the same page can differ by a few points with no deploy in between. Flag every drop and people soon ignore the check. Three habits keep it honest:

Measure the noise. Audit the unchanged site three times, note the largest swing per metric on your own pages, and set each tolerance above it. The numbers in the script below are placeholders, not recommendations.
Use absolute differences, not percentages: a percentage of a near-zero CLS baseline means nothing.
Confirm before failing. A breach is a candidate: rerun the list once and fail only if the same metric breaches again.

A tolerance hides real changes smaller than itself, so keep each release's result files and glance at the trend.

Gate on lab metrics, check field data later

Lab metrics come from Google's test device, so runs are comparable and they move the moment you deploy. Gate on labMetrics.lcpMs, labMetrics.tbtMs, labMetrics.cls and scores.performance.

Field data is real users from the Chrome UX Report, a 28-day 75th percentile, so a release from ten minutes ago has barely moved it. It cannot gate a deploy. It is null for low-traffic pages, and originFallback: true means origin-level numbers. Use it weeks later: rerun the list and compare fieldData.overallCategory.

Run the audits with the Actor

PageSpeed Insights Audit is an Apify Actor that calls the official PageSpeed Insights API v5 and returns one record per URL and strategy, with output fields documented as stable. Save this as input.json:

{
    "urls": [
        "https://www.example.com/",
        "https://www.example.com/products/",
        "https://www.example.com/blog/a-pinned-post"
    ],
    "strategy": "mobile",
    "categories": ["performance"]
}

The diff needs only the performance category. With "strategy": "both" each URL gets a mobile and a desktop record, compared separately. Pages Google cannot audit come back as success: false records with an errorType (dns, timeout, rate-limited and others), unbilled. The script must never read them as "no regression".

The diff script

Save this as diff.mjs (Node only). Exit codes: 0 clean, 1 confirmed regression, 2 some audits could not be compared, 64 bad usage. A metric regresses only if every successful "after" file is past its tolerance, which is how the rerun applies.

import { readFileSync } from "node:fs";

// Placeholder tolerances: replace them with what your own unchanged-site runs show.
const checks = [
  // label, value, which way is worse (1 = higher, -1 = lower), tolerance
  ["score", (r) => r.scores?.performance, -1, 5],
  ["LCP ms", (r) => r.labMetrics?.lcpMs, 1, 500],
  ["TBT ms", (r) => r.labMetrics?.tbtMs, 1, 200],
  ["CLS", (r) => r.labMetrics?.cls, 1, 0.05],
];

const [beforeFile, ...afterFiles] = process.argv.slice(2);
if (!afterFiles.length) {
  console.error("usage: node diff.mjs before.json after.json [rerun.json ...]");
  process.exit(64);
}
const load = (file) =>
  new Map(JSON.parse(readFileSync(file, "utf8")).map((r) => [`${r.strategy} ${r.url}`, r]));
const before = load(beforeFile);
const afters = afterFiles.map(load);
if (!before.size) {
  console.error("the before file has no records");
  process.exit(2);
}

let regressed = 0;
let noData = 0;
for (const [key, b] of before) {
  const runs = afters.map((m) => m.get(key));
  const good = runs.filter((r) => r?.success);
  const usable =
    b.success && good.length && checks.every(([, get]) => [b, ...good].every((r) => Number.isFinite(get(r))));
  if (!usable) {
    noData++;
    const why = [b, ...runs].map((r) => r?.errorType).filter(Boolean).join(" ");
    console.log(`NO DATA     ${key} ${why || "missing"}`);
    continue;
  }
  const bad = checks.filter(([, get, dir, tol]) => good.every((a) => dir * (get(a) - get(b)) > tol));
  for (const [label, get] of bad) console.log(`REGRESSION  ${key} ${label}: ${get(b)} -> ${get(good.at(-1))}`);
  if (bad.length) regressed++;
}
console.log(`${before.size} audits compared, ${regressed} regressed, ${noData} without data`);
process.exit(regressed ? 1 : noData ? 2 : 0);

Run it in CI

A short list fits in one synchronous call. Save this as audit.sh:

set -euo pipefail
curl -sSf -X POST \
  "https://api.apify.com/v2/acts/josh99smith~pagespeed-insights-audit/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d @input.json -o "$1"

The synchronous endpoint gives up after 300 seconds. The Actor's docs estimate about 10 minutes per 100 URLs, so that covers roughly 50 audits. For longer lists, start the run with POST /v2/acts/josh99smith~pagespeed-insights-audit/runs, poll it, then read its dataset. In GitHub Actions, with the token stored as a secret:

jobs:
  release:
    runs-on: ubuntu-latest
    env:
      APIFY_TOKEN: ${{ secrets.APIFY_TOKEN }}
    steps:
      - uses: actions/checkout@v4
      - run: bash audit.sh before.json
      - run: ./deploy.sh # your own deploy step
      - run: bash audit.sh after.json
      - name: Diff, with one rerun to confirm
        run: |
          node diff.mjs before.json after.json || {
            bash audit.sh rerun.json
            node diff.mjs before.json after.json rerun.json
          }

If the first diff fails, the job audits again and diffs with both "after" files: a one-off spike passes, a repeat fails. Exit 2 also triggers the rerun, which clears transient quota or timeout failures; if it fails again the build stays red.

Cost and limits

Price: $0.004 per successfully audited URL and strategy. Failed pages, invalid URLs and quota errors are free, and each run stops at the maximum cost you set.
Worked example: 20 URLs on mobile, before and after, is 40 audits: $0.16. A confirmation rerun adds 20 audits ($0.08), so $0.24 at most. Adding desktop doubles both figures.
Quota: the default built-in Google API key, and its daily quota, are shared by all users. When it runs out you get free rate-limited records, which the script reports as exit 2, not a pass. For CI, create your own free key (25,000 audits a day) and pass it as apiKey, built into input.json from a CI secret, not committed.

If this saves you time, a review on the Store page helps other people find it, and a star on GitHub helps too.

Disclosure: I built this Actor. Source: github.com/josh99smith/pagespeed-insights-audit. PageSpeed Insights and Lighthouse are Google trademarks; the Actor is not affiliated with Google.

Turn a list of prospect websites into honest page-speed reports for outreach

Joshua Smith — Wed, 14 Oct 2026 13:10:13 +0000

A cold email saying "your website is slow" gets deleted. One saying "your services page takes N seconds to show its main content on a phone, and two fixes would shorten that" gets read, because the owner can check it. Below: pages to pick, four numbers, a ranking script and the etiquette. Google's PageSpeed Insights API does the measuring; PageSpeed Insights Audit is an Apify Actor that runs it over a list of URLs.

Pick the pages that matter

Audit three or four pages per prospect, chosen as a customer would use the site:

The homepage, because the owner has seen it.
The page that earns money: the main service, product or booking page.
One page that attracts visitors, such as a popular blog post.
The contact or checkout page.

Use mobile, since Google Search ranks with mobile data. Open each URL in a browser: Google must fetch it publicly, so logins and staging fail.

Four numbers an owner can follow

Performance score (scores.performance), 0 to 100. 90 or more is "good", 50 to 89 "needs improvement".
Time until the main content shows (labMetrics.lcpMs, milliseconds, so divide by 1,000). Describe it as when the biggest thing on screen, usually a hero image or headline, has appeared.
What real visitors get (fieldData.overallCategory: FAST, AVERAGE or SLOW). It is Chrome user data, stronger evidence than the lab score. It is null for low-traffic pages, and originFallback: true means whole-site data. Say which you have.
The biggest fix (the first entry of opportunities, with its title and savingsMs).

If they disagree (a poor score but FAST visitor data), say so or drop the prospect.

Turn opportunities into plain English

Google words findings for developers ("Eliminate render-blocking resources"). Write one sentence per common id, about what a visitor notices:

render-blocking-resources: "Visitors wait on a blank screen while files load."
unused-javascript: "The page downloads code it never runs."

Present savings as estimates, show at most three, and do not add them up, because they overlap. For an id without a sentence, use Google's title rather than guess.

Run the audits

Input for two prospects. categories is narrowed because a speed report needs nothing else; includeAuditDetails adds opportunities:

{
    "urls": [
        "https://www.prospect-one.example/",
        "https://www.prospect-one.example/services",
        "https://www.prospect-two.example/",
        "https://www.prospect-two.example/book"
    ],
    "strategy": "mobile",
    "categories": ["performance"],
    "includeAuditDetails": true
}

Save it as input.json and make one call:

curl -X POST "https://api.apify.com/v2/acts/josh99smith~pagespeed-insights-audit/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" -d @input.json > results.json

The call waits for the run to finish, so keep it to a short list; for a longer one, start the run in the Console and download the Output tab as JSON. Allow about 10 minutes per 100 URLs at the default concurrency.

Rank prospects and write one summary each

Run python rank_prospects.py results.json (Python 3.9+). The script groups pages by hostname, keeps successful mobile records, ranks sites by mean performance score (lowest first) and writes one report-01-<site>.md-style file per site.

import json, sys
from collections import defaultdict
from urllib.parse import urlparse

PLAIN = {
    "render-blocking-resources": "Visitors wait on a blank screen while files load.",
    "unused-javascript": "The page downloads code it never runs.",
}
host = lambda u: urlparse("//" + u.split("//", 1)[-1]).hostname.removeprefix("www.")
score = lambda p: p["scores"]["performance"]

ok, bad = defaultdict(list), defaultdict(list)
for r in json.load(open(sys.argv[1], encoding="utf-8")):
    if r.get("strategy") == "mobile":
        usable = r.get("success") and None not in (score(r), r["labMetrics"]["lcpMs"])
        (ok if usable else bad)[host(r["url"])].append(r)

avg = lambda h: sum(map(score, ok[h])) / len(ok[h])
ranked = sorted((h for h in ok if min(map(score, ok[h])) < 90), key=avg)

for rank, h in enumerate(ranked, 1):
    pages = sorted(ok[h], key=score)
    out = [f"# {h}: where the site loses points", "",
           f"Google Lighthouse, mobile, {pages[0]['fetchedAt'][:10]}. Scores move a few points between runs.", "",
           "| Page | Score | Main content visible | Real visitors |", "|---|---|---|---|"]
    fixes = []
    for p in pages:
        field = p.get("fieldData") or {}
        real = field.get("overallCategory", "NONE").lower().replace("none", "not enough data")
        if field.get("originFallback"):
            real += " (whole site)"
        out.append(f"| {p['url']} | {score(p)} | {p['labMetrics']['lcpMs'] / 1000:.1f} s | {real} |")
        for o in (p.get("opportunities") or [])[:2]:
            ms = o.get("savingsMs") or 0
            note = f" Estimated saving: {ms / 1000:.1f} s." if ms else ""
            fixes.append((ms, f"- {p['url']}: {PLAIN.get(o['id'], o['title'])}{note}"))
    if fixes:
        out += ["", "## Biggest fixes", "", "Estimates overlap; do not add them up.", ""]
        out += [text for _, text in sorted(fixes, reverse=True)[:3]]
    open(f"report-{rank:02d}-{h}.md", "w", encoding="utf-8").write("\n".join(out) + "\n")
    print(rank, h, f"avg {avg(h):.0f}", f"failed {len(bad[h])}")

for h in sorted(set(ok) | set(bad)):
    if h not in ranked:
        print("not reported:", h, "(all 90+)" if h in ok else "(failed)")

Sites where every page scores 90 or more are skipped: there is no honest story. Failed pages are counted, not reported, so an unloadable page never reads as a bad score. Good pages stay in the table. Read each file before sending.

Be accurate, be kind

Public pages only. Never audit staging sites or anything behind a login.
Be accurate. Give the URL, date, device, and that it is a lab result; re-run borderline pages.
Do not exaggerate. Quote what you measured, and never turn seconds into money: you cannot see their analytics.
Do not scare. A score of 62 is "needs improvement", not "failing". Say what is fine.
Send once and accept a no. Check outreach rules where you and the prospect are based.

Cost and limits

$0.004 per audited page and device strategy. Worked example: 40 prospects with 3 pages each on mobile is 120 audits, or $0.48. Adding desktop makes 240 audits, $0.96. If 10 of the 120 pages cannot be loaded, 110 audits are billed: $0.44. No start-up charge, and a run stops at the maximum cost you set.

Variance. Lighthouse scores differ between runs by a few points.
Lab versus field. scores.performance is a lab estimate; real-user data is stronger but needs enough traffic.
Failed pages. Pages Google cannot load return free success: false records with an errorType such as dns or timeout.
API key. By default the Actor uses a built-in key shared by all its users: 25,000 requests a day and a few hundred a minute between them. When that runs out you get free rate-limited records; retry later, or paste your own free Google key into apiKey for a dedicated quota.

If this saves you time, a review on the Store page helps other people find it, and a star on GitHub helps too.

Disclosure: I built this Actor. Source: github.com/josh99smith/pagespeed-insights-audit. PageSpeed Insights and Lighthouse are Google trademarks; the Actor is not affiliated with Google.

Track competitor YouTube uploads every week and send them to Slack or Google Sheets

Joshua Smith — Sat, 10 Oct 2026 13:09:17 +0000

Competitor tracking is usually a habit you skip: open a dozen channel pages, scroll to find what is new, guess how it did. A weekly job fixes that: once a week, fetch only the videos each channel published in the last seven days, store them, and compare with last week. Below: what to measure, how a date filter keeps cost low, a comparison script, and the limits.

What to track each week

Each video record from YouTube's official Data API carries enough for four signals:

Upload cadence. New videos per channel per week, from channelTitle and publishedAt.
Title patterns. Length, numbers, question marks and "how to" openers from title. One week proves little; a few months of rows show habits.
Length. durationSeconds. Shorts appear in channel uploads like any other video, so split formats before taking a median.
Views after N days. viewCount next to publishedAt and scrapedAt, so every number comes with the video's age when it was read.

Why the date filter keeps a weekly job cheap

A channel's uploads can be read newest first, so "what is new this week" means reading until you reach a video older than your cutoff, then stopping. Reading uploads costs about 1 quota unit per 50 videos. A search page costs 100, so do not build this on search.

Best Damn YouTube Scraper does that through its publishedAfter input. Paging stops as soon as older videos appear, and billing is per delivered video, so the back catalogue is never delivered and never billed. Without it, a weekly run at the default maxResults of 50 re-delivers each channel's latest 50 videos, mostly ones you already have, and bills them again.

The weekly input

Use this input and swap in your competitors' @handles, channel URLs or channel IDs:

{
    "startUrls": [
        "https://www.youtube.com/@YouTube",
        "https://www.youtube.com/@jawed"
    ],
    "publishedAfter": "7 days",
    "maxResults": 0
}

maxResults: 0 means no cap, which is safe because the date filter does the limiting. publishedAfter also takes a date such as 2026-01-31 or a period such as 2 weeks. Save the input as a task, put it on a weekly schedule in Apify, and add your own YouTube API key in apiKey (see limits).

From code

For your own cron, one call returns the dataset:

curl -X POST "https://api.apify.com/v2/acts/josh99smith~youtube-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "startUrls": ["https://www.youtube.com/@YouTube", "https://www.youtube.com/@jawed"], "publishedAfter": "7 days", "maxResults": 0 }' \
  > "week-$(date +%F).json"

A small week-over-week comparison

From week two, compare the two latest files with python compare.py this-week.json last-week.json:

import json, sys
from collections import defaultdict
from datetime import datetime
from statistics import mean, median

def ts(s):
    return datetime.fromisoformat(s.replace("Z", "+00:00"))

def load(path):
    rows = json.load(open(path, encoding="utf-8"))
    good = [r for r in rows if r.get("success") and r.get("liveStatus") != "upcoming"]
    return good, {r.get("errorType") for r in rows if not r.get("success")}

def summarise(rows):
    by_channel = defaultdict(list)
    for r in rows:
        by_channel[r["channelTitle"]].append(r)
    return {ch: {
        "uploads": len(vs),
        "minutes": round(median(v["durationSeconds"] for v in vs) / 60, 1),
        "title_chars": round(mean(len(v["title"]) for v in vs)),
        "age_days": round(median((ts(v["scrapedAt"]) - ts(v["publishedAt"])).days for v in vs)),
        "views": median(v["viewCount"] or 0 for v in vs),
    } for ch, vs in by_channel.items()}

this_rows, errors = load(sys.argv[1])
last_rows, _ = load(sys.argv[2])
if errors:
    print("WARNING: failed records", errors, "- this week may be incomplete")

now, before = summarise(this_rows), summarise(last_rows)
for ch in sorted(set(now) | set(before)):
    n, b = now.get(ch, {}), before.get(ch, {})
    print(ch, "uploads", b.get("uploads", 0), "->", n.get("uploads", 0), n)

It keeps only success: true records and skips liveStatus: "upcoming" streams, which have no views yet. It warns when any record failed: a quota error produces free rate-limited records instead of a failed run, so an empty week would otherwise look like a quiet one. Median age sits beside median views so you can see what the views belong to.

Compare like with like. A video one day old has fewer views than one six days old, so a change in median views mostly reflects when the channel posted. For a fairer number, take a second reading: bare video IDs are valid startUrls entries, so a week later you can send last week's IDs and read the same videos again. Each re-read is billed at the usual per-video price.

Send it to Slack or a sheet

Apify integrations move finished results onward without a download. The Actor's README lists Make, Zapier, n8n, Slack, Google Drive and Airbyte, with Slack posts and Google Sheets rows as example uses.

Slack: the Slack integration guide covers sending a task's results to a channel. Good for noticing new videos, poor for history.
Google Sheets: append rows every week so the history builds. Treat videoId as the key and drop duplicates, because a delayed run can overlap the previous window.
Your own endpoint: webhooks fire when a run succeeds, fails or times out. Point one at a small service that runs the comparison and posts the summary.

Cost and limits

$0.001 per video delivered, so 1,000 videos cost $1.00. Private, deleted and unavailable videos, invalid inputs and quota errors cost nothing, there is no start-up charge, and a run stops at the maximum cost you set.

Worked example, with assumed numbers: 20 channels publish 60 videos between them in a week. At 60 x $0.001, a weekly run costs $0.06, or $3.12 over 52 weeks. Without the filter, 20 channels at 50 videos each return up to 1,000 videos per run: $1.00 a week, $52.00 a year, nearly all of it videos you already have. Re-reading last week's 60 videos for the second reading adds another $0.06 a run.

Limits:

Quota. By default the Actor uses a built-in key whose 10,000 daily units are shared by all its users. For a scheduled workload, create your own free key in the Google Cloud Console with the YouTube Data API v3 enabled, and paste it into apiKey. When a quota runs out, the run stops cleanly and returns free rate-limited records; quotas reset at midnight Pacific Time. The SUMMARY record in the key-value store lists failures and quota units used.
Young videos. Early view counts are small and noisy. Compare videos of similar age.
Public data only. No login is used, so nothing from a channel owner's private analytics is available, and private, unlisted and members-only videos are not included. likeCount and commentCount are null when hidden, and YouTube rounds subscriber counts.

If this saves you time, a review on the Store page helps other people find it, and a star on GitHub helps too.

Disclosure: I built this Actor. Source: github.com/josh99smith/youtube-scraper. YouTube is a trademark of Google, and the Actor is not affiliated with Google.

Find bug reports and feature requests in YouTube review-video comments

Joshua Smith — Fri, 09 Oct 2026 13:10:13 +0000

People who watch a long review or a setup tutorial are informed critics, and they leave their complaints in the comments. This post covers choosing the videos, filtering by keyword and date, de-duplicating, tagging comments as bug, feature request, question or praise, and ranking the result for a product or support team.

Where the feedback is

In rough order of usefulness:

Setup and tutorial videos. Viewers get stuck here: questions and bug reports.
Independent reviews and unboxings of your product. Feature gaps, price, build quality.
The same videos for a competitor. Their users' complaints are your opening; their praise is the bar.
Your own channel.

Search YouTube for the product name plus "review", "unboxing", "tutorial", "problem" and "vs" your main rival. Keep public videos with comments on, published after the product version you care about. Private and members-only videos give you nothing, and videos made for kids never have comments.

Filter before you collect

Keyword. The Actor's keyword option passes your words to YouTube's own comment search, so you pay only for matching comments. It applies to top-level comments, so a complaint inside a reply thread is not searched. It is also YouTube's search, not a regular expression, so do not assume exact substring matching; check a sample. Run one theme at a time (battery, then crash, then refund). A filtered run shows what people say, not what share of viewers say it; for shares, also pull an unfiltered sample.

Date. Set "Only comments after" to the release date of the version you are studying, as a date (2026-03-01) or a relative period such as 3 months. With "Newest first" the Actor stops paging once it reaches older comments. Use "Top comments" instead for long-standing complaints other viewers have voted up.

Collecting the comments

Best Damn YouTube Comments Scraper is an Apify Actor that reads comments through the official YouTube Data API v3: no browser, no login. Give it video URLs (or a channel, and it reads that channel's most recent videos):

{
    "startUrls": [
        "https://www.youtube.com/watch?v=VIDEO_ID_1",
        "https://www.youtube.com/watch?v=VIDEO_ID_2"
    ],
    "searchTerms": "battery",
    "sortBy": "time",
    "publishedAfter": "3 months",
    "maxComments": 200,
    "authorData": "hash"
}

maxComments is per video. authorData: "hash" swaps the commenter's channel ID for a stable hash and drops name and avatar. Save the block as input.json and call the API:

curl -X POST "https://api.apify.com/v2/acts/josh99smith~youtube-comments-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" -d @input.json

Each record is one comment. Fields used below: success, commentId, commentUrl, text, likeCount, isByVideoOwner, authorChannelId. Unreadable videos come back as free records with success: false and an errorType such as comments-disabled.

De-duplicate, tag and group

De-duplicate because the same video can arrive twice (as a URL and through a channel), merged keyword runs overlap, and copy-pasted comments inflate a theme. Match on commentId and on normalised text. Skip comments where isByVideoOwner is true; the creator is not the audience.

Tag with rules where the first match wins (bugs, then requests, questions, praise) and group by theme. Counting distinct authorChannelId values works with hashed IDs, so you count people without knowing who they are.

import json, re
from collections import defaultdict
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("josh99smith/youtube-comments-scraper").call(
    run_input=json.load(open("input.json")))

seen, groups = set(), defaultdict(lambda: {"people": set(), "likes": 0, "links": []})
TAGS = [  # first match wins
    ("bug", r"crash|broke|stopped working|doesn'?t work|won'?t (start|connect)"),
    ("request", r"i wish|should (have|add)|please add|would be (nice|great)"),
    ("question", r"\?|how (do|can) i"),
    ("praise", r"love|great|works well"),
]
THEMES = {"battery": r"batter|charg", "app": r"\bapp\b|firmware", "price": r"price|expensive"}

for c in client.dataset(run["defaultDatasetId"]).iterate_items():
    if not c["success"] or c["isByVideoOwner"]:
        continue
    t = c["text"].lower()
    key = re.sub(r"\W+", " ", t).strip()
    if c["commentId"] in seen or key in seen:
        continue
    seen.update([c["commentId"], key])
    tag = next((n for n, p in TAGS if re.search(p, t)), "other")
    for theme, p in THEMES.items():
        if re.search(p, t):
            g = groups[(tag, theme)]
            g["people"].add(c["authorChannelId"])
            g["likes"] += c["likeCount"]
            g["links"].append(c["commentUrl"])

for (tag, theme), g in sorted(groups.items(), key=lambda kv: (-len(kv[1]["people"]), -kv[1]["likes"])):
    print(tag, theme, len(g["people"]), g["likes"], g["links"][:2])

Replace THEMES with your product's vocabulary. When keyword themes stop being enough, embed each text with any sentence-embedding model, cluster the vectors (k-means is fine) and name each cluster by reading its top comments.

Turn it into a prioritised list

Rank each tag-and-theme group by distinct commenters, then total likeCount; a like is another viewer saying "me too". Each row needs the theme, tag, commenter count, likes, commentUrl links for context, and an owner: bugs to engineering or support, requests to product, repeated questions to whoever writes docs or tutorials, praise to marketing as things not to break.

Read a random sample from every tag before sharing. Keyword rules misread sarcasm: "love how it never connects" lands under praise here. Commenters are self-selected, not your customer base, so treat the list as a starting point.

Cost and limits

Price. $0.0004 per delivered comment or reply ($0.40 per 1,000). Ten videos capped at 200 comments each is at most 2,000 comments, so at most $0.80. Videos with comments off, private or deleted videos, invalid URLs and quota errors are free; there is no start fee and a run stops at the maximum cost you set.
Quota. By default the Actor uses a built-in API key shared by all its users, with a daily quota of 10,000 units and one unit per page of up to 100 comments. If it runs out, the run stops cleanly and the remaining videos come back as free rate-limited records; the quota resets at midnight Pacific Time. Your own free key from the Google Cloud Console, pasted into apiKey, gives you roughly a million comments a day. The SUMMARY record in the key-value store lists comments per video, failures and quota units used.
Fewer comments than shown. YouTube's count includes replies and held or removed comments; the API returns what is currently public.
Public data only. No login, so nothing private or members-only.

Treat comments as aggregate research

Comments are personal data under GDPR and similar laws, so you need a legitimate purpose. Work with themes, not people. Use hash or omit for authorData, do not contact commenters, and if you quote a comment in a report, leave the name out.

If this saves you time, a review on the Store page helps other people find it, and a star on GitHub helps too.

Disclosure: I built this Actor. Source: github.com/josh99smith/youtube-comments-scraper. YouTube is a trademark of Google; the Actor is not affiliated with Google.