Maker disclosure: I run ScrapeMole, which sells these endpoints. All numbers below come from our own live endpoints and our on-chain ledger, measured on 28 Oct 2026. They're small, and I'm not rounding them up.

x402 turns the old HTTP status 402 Payment Required into a working payment flow. The client asks for a resource and gets a 402 with a price. It signs a USDC transfer, retries, and gets the data. There's no API key, no account and no monthly plan, which is why it fits AI agents that need one piece of data, once, from a service they've never seen.

We run 12 x402 origins on the Cloudflare Workers free plan. Here's what they look like from the outside, plus what happened when we used x402 as a buyer inside LangChain and Cloudflare Agents.

The catalog, measured

Reading the 12 public openapi.json files on 28 Oct 2026 gives:

• 77 paid endpoints, every one with a price in x-payment-info
• Min $0.001, median $0.002, max $0.01 per call
• Categories: web and news search, page reader, YouTube, Google Trends, domains/DNS/WHOIS/SSL, on-chain prices and balances, SEC company filings, Wikipedia, FX/time/weather, npm/PyPI packages, arXiv and more

What an agent sees on the first request

curl -i "https://pulse.scrapemole.workers.dev/v1/time/now?tz=Europe/Madrid"

Decoded payment-required header (trimmed):

{"accepts": [
  {"network": "eip155:8453", "amount": "1000", "asset": "0x8335…2913"},
  {"network": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp", "amount": "1000", "asset": "EPjF…Dt1v"}
]}

That's $0.001 in USDC, payable on Base or Solana. Measured round-trip for the unpaid 402, five calls in a row from Europe: 766, 826, 39, 37, 27 ms. The first two were cold isolates; warm ones answer in about 30–40 ms.

Two design choices that matter for agents:

1. Bad input never costs money. Inputs are checked before the 402 is issued. In our last validation matrix, 573 of 574 malformed inputs got a free 400 instead of a price quote.
2. Failures are never settled. Payment only settles on a response below 400, so a timeout or upstream error costs $0.

There's also one MCP endpoint per origin (/mcp), so MCP clients that handle x402 can call the same tools.

Using x402 as a buyer: two framework integrations

To test the buyer side, we wrote two small integrations against a third-party x402 API (Blockchain IQ's market brief):

The pattern that makes x402 safe inside an agent is a per-call spend cap checked before signing:

client = BlockchainIQClient(max_usdc_per_call="0.01")
price = client.quote("brief")   # free: reads the unpaid 402
if price > 10_000:              # atomic USDC, 6 decimals
    raise SystemExit("quote above $0.01, refusing to pay")

The model chooses whether to call the tool, but it never chooses how much to pay. Both repos can be cloned from https://scrapemole.pages.dev/code/.

What we've actually earned

From our on-chain ledger (Base, last checked 27 Oct 2026, 21:50 CET):

• $0.501 USDC lifetime, 122 settled payments, 4 paying wallets
• Two of those wallets are very likely the same operator (one funded the other)
• Almost every paid call we could attribute was YouTube search or transcripts
• Solana went live on 26 Oct and has received $0 so far

So x402 works mechanically: unknown agents did pay, and one came back many times. We're listed on x402scan, x402dash and 402 Index, but we can't tell which listing sent them. But volume per seller is tiny. Public x402 stats we read on 19 Oct showed a median seller earning about $0.01 over 30 days. If you're building here, design for many small integrations rather than one big customer.

If you want to try it

• No wallet: most of the same data is on the Apify Store, billed per result: https://apify.com/scrapemole
• With a wallet: https://scrapemole.pages.dev (each tool page shows the curl, the price and the MCP config)

Questions about the cap pattern or the 402 validation order are welcome. I'll answer in the comments.

Maker disclosure: I build ScrapeMole, which publishes the YouTube Comments and Transcript Actors used below. The open-source libraries I compare against are good. This is where they differ, measured on 28 Oct 2026.

If you're feeding YouTube into a sentiment model or a RAG index, you need two things: comments and transcripts. I ran the free Python libraries and our Actors on the same videos from the same Linux box, with no proxy.

Comments: 200 top comments from one video

The video is 3Blue1Brown's "But what is a neural network?" (aircAruvnKk, about 9,442 comments).

DIY with youtube-comment-downloader 0.1.84:

from youtube_comment_downloader import YoutubeCommentDownloader, SORT_BY_POPULAR
d = YoutubeCommentDownloader()
for c in d.get_comments_from_url(URL, sort_by=SORT_BY_POPULAR, language="en"):
    ...

What I measured:

• The first 200 rows held only 20 top-level comments. The other 180 were replies, interleaved with their parents.
• Collecting 200 top-level comments meant pulling 1,346 rows and took 60.2 s.
• Without language="en", the box's IP got localized strings back: likes as "14 tūkst." and dates as "prieš 7 metus" (Lithuanian). With language="en" you get "14K" and "7 years ago", which you still have to parse.

Our YouTube Comments Scraper (same code as on Apify, run locally):

{ "videos": ["https://www.youtube.com/watch?v=aircAruvnKk"], "maxComments": 200, "sortBy": "top" }

• 200 top-level comments in 4.5 s, 0 errors
• Replies are off by default and can be turned on with includeReplies
• likeCount comes back as an integer (14000), publishedAtApprox as a date, totalCommentsOnVideo as 9442, plus isPinned, isHeartedByCreator, isByVideoCreator, replyCount, videoTitle and 23 fields in total

Cost: the Actor is $0.001 per comment on Apify's free tier, so these 200 comments are $0.20. Other public prices per comment on 28 Oct 2026 (Apify Store API): streamers/youtube-comments-scraper $0.002, apidojo $0.0005 plus $0.001 per query, solidcode $0.00035, supreme_coder $0.00025 plus start. We're not the cheapest. The point is clean top-level rows with numeric fields. The DIY library is free if you're happy to filter and parse.

Transcripts: 10 well-known videos

DIY with youtube-transcript-api 1.2.4, languages=["en"]: 9 of 10 in 7.1 s total (0.6–0.9 s each). The miss was PSY's "Gangnam Style" (9bZkp7q19f0), which raised NoTranscriptFound because it has Korean auto-captions and no English track. You can handle that in a few more lines with list(). Out of the box, though, you get text and timestamps only, with no video metadata.

Our YouTube Transcript Scraper on Apify (same 10 IDs, fallbackToAnyLanguage: true, includeSrt: true):

• 10 of 10 ok, 7.2 s run time. Gangnam Style came back in Korean (ko, auto-generated, 67 segments).
• Word counts matched the DIY run exactly on all 9 shared videos (for example 3,357 words / 286 segments on aircAruvnKk, and 21,030 / 2,955 on Karpathy's "Let's build GPT")
• 29 fields per video, including SRT, title, channel, view count, duration, publish date and available languages
• Apify platform usage for the run: $0.0024. The transcript event costs $0.004 per video on the free tier ($4 per 1,000).

For comparison, the official YouTube Data API's captions.download costs 200 quota units and "requires the user to have permission to edit the video", so it only works on your own videos. Its commentThreads.list costs 1 unit for up to 100 comments, and the default quota is 10,000 units/day for non-search endpoints. That's fine for comments if you have a Google Cloud project and a key.

So which should you use?

• One-off notebook: the free libraries. Remember language="en" and filter out replies.
• Scheduled pipeline, many videos, or a no-code tool (n8n, Make, Zapier): the Actors. You get one JSON schema, numeric fields, no IP-locale surprises, and you don't pay for videos without captions.
• AI agents with a wallet: the same transcript and comments endpoints are on x402 at $0.002 per call, with no API key.

Links:

• Comments Actor: https://apify.com/scrapemole/youtube-comments-scraper
• Transcript Actor: https://apify.com/scrapemole/youtube-transcript-scraper
• Sentiment walkthrough (VADER, weighted by likes): https://scrapemole.pages.dev/guides/youtube-comments-sentiment-analysis-python/
• ScrapeMole: https://scrapemole.pages.dev

Method: single runs on 28 Oct 2026, around 12:00 CET, from one datacenter IP. Timings vary run to run, and your IP may be treated differently by YouTube.

Maker disclosure: I build ScrapeMole, including the ATS Jobs Scraper used below. The DIY script is free and works; this post shows exactly where each approach wins.

Job postings are one of the few public signals that tell you what a company is about to spend money on. A burst of "Go To Market" roles means a sales push; ten new "Scaling" roles at an AI lab means data-center spend. Most companies publish these through an applicant tracking system (ATS), and Greenhouse, Lever and Ashby all expose a public, no-login JSON feed of open roles.

So the data is easy to get. The real work is the cleanup afterwards. I measured both routes on 28 Oct 2026 against three real boards: Airbnb (Greenhouse), Palantir (Lever) and OpenAI (Ashby).

Route 1: DIY with requests (17 lines)

import requests
def fetch(ats, slug):
    if ats == "greenhouse":
        js = requests.get(f"https://boards-api.greenhouse.io/v1/boards/{slug}/jobs", params={"content": "true"}).json()["jobs"]
        return [{"title": j["title"], "location": (j.get("location") or {}).get("name"), "url": j["absolute_url"]} for j in js]
    if ats == "lever":
        js = requests.get(f"https://api.lever.co/v0/postings/{slug}", params={"mode": "json"}).json()
        return [{"title": j["text"], "location": j["categories"].get("location"), "url": j["hostedUrl"], "salary": j.get("salaryRange")} for j in js]
    if ats == "ashby":
        js = requests.get(f"https://api.ashbyhq.com/posting-api/job-board/{slug}", params={"includeCompensation": "true"}).json()["jobs"]
        return [{"title": j["title"], "location": j.get("location"), "url": j["jobUrl"],
                 "salary": (j.get("compensation") or {}).get("compensationTierSummary")} for j in js]

Measured result (one run from a datacenter box, no proxy):

That's fast and free. But three schemas means three field maps, three date formats and three location shapes. Greenhouse and Lever (for this board) give you no structured salary at all. The pay range is buried in the HTML description ("India Annual Pay Range ₹1,610,000 — ₹2,110,000 INR").

Route 2: the ATS Jobs Scraper on Apify

Input:

{ "companies": ["greenhouse:airbnb", "lever:palantir", "ashby:openai"], "maxJobsPerCompany": 1000 }

Measured result (same day, the same Actor code run locally with descriptions on):

• 1,307 jobs, 0 errors, 5.7 s (7.9 s on an earlier run the same morning).
• One flat schema with 27 fields for all three ATSs: title, companyName, location(s), country, remote, workplaceType, department, team, employmentType, postedAt, salaryMin, salaryMax, salaryCurrency, salaryInterval, salaryText, salarySource, description, applyUrl…
• postedAt was present on 1,307 of 1,307 rows. For Greenhouse it uses first_published, so edits don't make old jobs look new.
• Salary found on 1,051 of 1,307 jobs (80%): OpenAI 657/805, Airbnb 160/196, Palantir 234/306. For Greenhouse and Lever, the salary is parsed out of the description text.

Both ends of the range come through: salaryMax is filled on 1,001 of the 1,051 jobs with a salary (Airbnb 159/160, Palantir 201/234, OpenAI 641/657). The rest have a single figure in the posting (e.g. a $6,700 monthly internship rate). Greenhouse's "₹1,610,000 — ₹2,110,000 INR" becomes salaryMin: 1610000, salaryMax: 2110000, salaryCurrency: "INR", salaryInterval: "year".

The hiring-intent part: what changed this week

Add "postedWithinDays": 7 and the same three boards return 99 jobs posted in the last 7 days (5.7 s): OpenAI 75, Airbnb 19, Palantir 5. Grouped by department, the top three were OpenAI Go To Market (12), OpenAI Scaling (10) and OpenAI Marketing (7).

That's the useful output for a sales or research workflow. You get a weekly diff of who is hiring for what, not a 1,307-row dump. For a scheduled run, onlyNew: true keeps state between runs and only returns (and only charges for) jobs it hasn't seen before.

Cost per 1,000 jobs (public Apify Store prices, read 28 Oct 2026)

The honest verdict: if you track one ATS and don't need salary, use the 17-line script. Use the Actor when you track many companies across several ATSs, need salary normalized into numbers, or want "only new since last run" on a schedule without running your own state store.

• Actor: https://apify.com/scrapemole/ats-jobs-scraper
• Full Python walkthrough: https://scrapemole.pages.dev/guides/greenhouse-lever-ashby-jobs-python/
• ScrapeMole: https://scrapemole.pages.dev

Method: both scripts were run on 28 Oct 2026, around 12:00 CET, from one Linux box with no proxy. The timings come from a single run each, so expect variance.