DEV Community: Truffle Pig Data

How to find investors for a startup in 2026 (with the cheque sizes attached)

Truffle Pig Data — Mon, 24 Aug 2026 15:25:47 +0000

Every founder I know hits the same wall on a raise. You can find investor names in an afternoon. What you cannot find, without a lot of tab-switching, is which of them writes a cheque the size of your round.

Signal by NFX publishes that. It maintains public investor lists organised by sector and stage, and each investor carries a cheque-size range. The lists are public, no login, but they paginate eight at a time through a private endpoint, so copying one into a spreadsheet by hand is a genuinely bad afternoon.

I did it by hand once. Then I stopped doing it by hand.

Disclosure: the Apify links in this post are affiliate links. If you run the Actor, I may earn a referral commission at no extra cost to you.

What the NFX Signal investor data actually contains

The NFX Signal Investor API returns venture investors, VC firms, and the investor-list catalog as structured JSON, including the minimum, target, and maximum cheque each investor writes.

What you get	Detail
Investor	name, position, profile link, headshot
Cheque size	`minInvestment`, `targetInvestment`, `maxInvestment` in USD
Firm	`firmName`, `firmUrl`
Context	investment locations, other lists they appear on, source list stage and sector
Catalog	349 lists across 103 sectors, four stages, and 14 geographies

The largest single list, fintech-seed, holds 8,775 investors. san-francisco-bay-area holds 8,246.

Who this is for

Founders raising, who need a target list ordered by the cheque they actually need.
Anyone selling to VCs, who needs a firm directory for a CRM rather than individual partners.
Analysts mapping a market, who want to see which firms show up across AI, FinTech, and climate lists.

The DIY path, and where it breaks

You can do this by hand. Open a list page, copy the eight visible investors, click load more, repeat. For a 300-investor list that is roughly 38 rounds of clicking.

Scripting it is not much better at first pass. The page is server rendered, so the first batch is in the HTML, but everything after that comes from a cursor-paginated endpoint that the page calls as you scroll. You end up reverse engineering the pagination, then handling the fact that cheque sizes come back as strings, that geography is modelled as a sector rather than a location field, and that a "firm" on a list is only a name and a link until you enrich it.

None of that is hard. It is just a day you did not plan to spend.

The shortcut: run it as an API

Console. Open the NFX Signal Investor API, pick a mode, hit Start.

REST. One call, no login to the source needed:

curl -X POST "https://api.apify.com/v2/acts/johnvc~nfx-signal-investor-api/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"investors","listSlugs":["saas-seed"],"maxItems":50}'

The run endpoint is documented in the Apify API reference.

MCP. Point any MCP client at the server below and an agent can call it directly:

https://mcp.apify.com/?tools=actors,docs,johnvc/nfx-signal-investor-api

That last one matters more than it looks. "Which seed investors back developer tools, and what do they write?" is a question an agent can now answer from live data instead of memory.

How to find investors for a startup, by stage and cheque size

The one I use most. Pick the lists that match your round, then sort by targetInvestment:

{ "mode": "investors", "listSlugs": ["saas-seed"], "maxItems": 100 }

{
  "result_type": "investor",
  "name": "Brendan Wallace",
  "position": "managing_partner",
  "minInvestment": 10000000,
  "targetInvestment": 12500000,
  "maxInvestment": 25000000,
  "firmName": "Fifth Wall Ventures",
  "personUrl": "https://signal.nfx.com/investors/brendan-wallace"
}

Ready to run: Find Investors for Your Startup by Stage and Check Size.

Getting a list of VC firms in San Francisco

Switch to firms mode and you get the firm directory instead of individual partners, which is the shape you want for a CRM import.

{ "mode": "firms", "listSlugs": ["san-francisco-bay-area"] }

Ready to run: List of VC Firms in San Francisco Bay Area.

Pre seed investors, with the cheque sizes attached

Pre-seed is the stage where cheque size matters most and is published least consistently. Three sector lists in one run:

{ "mode": "investors", "listSlugs": ["fintech-pre-seed", "saas-pre-seed", "ai-pre-seed"], "maxItems": 500 }

Ready to run: Pre Seed Investors List With Check Sizes.

Using it as a Crunchbase alternative

It complements those tools rather than replacing them, and the difference is worth being precise about. Crunchbase and PitchBook are company-centric: they tell you what a company raised. This is investor-centric: it tells you who invests, at what stage, and what they write. You can attach Crunchbase data per firm in the same run:

{ "mode": "investors", "listSlugs": ["ai-seed"], "maxItems": 100, "enrichWithCrunchbase": true }

Ready to run: Crunchbase Alternative for Investor and VC Firm Data.

Browsing the whole VC database first

Slugs are not guessable, so start here. lists mode returns the catalog with a slug, stage, sector, and investor count for each of the 349 lists.

{ "mode": "lists" }

Ready to run: VC Database Export by Sector and Stage.

Exporting a Signal NFX list to JSON or CSV

If you just want one list out of the browser and into a file, this is the plain version, no enrichment, no filtering: Export Signal NFX Investor Lists to JSON or CSV.

Tracking new investors entering your sector

An export is a snapshot. Save the input as a Task, attach a monthly Schedule, and diff the runs to see who entered your sector: Track New Investors Joining a VC List Each Month.

The example repo

johnisanerd / Apify-NFX-Signal-Investor-API

NFX Signal Investor API examples: find investors, check sizes, and a list of VC firms from Signal by NFX as JSON. Python + MCP quick start.

NFX Signal Investor API: find investors, check sizes, and VC firms

Python and MCP examples for the NFX Signal Investor API on Apify. It turns Signal by NFX investor lists into structured JSON: venture investors, the VC firms behind them, and the check size each investor actually writes.

Not affiliated with, endorsed by, or connected to NFX. It reads the same public investor lists any visitor can browse.

Text walkthrough

If you have ever searched for how to find investors for a startup, the hard part is not finding names, it is finding the right names with the right cheque size. This API starts from the public Signal NFX investor lists: 349 of them, spanning 103 sectors and four stages from pre-seed to Series B. Run mode: "lists" first and you get the whole catalog with a slug, a stage, a sector, and an investor count for each one. Pick…

View on GitHub

Python quick start with uv, five task-aligned helper functions, and MCP install walkthroughs for Claude Cowork, Claude Code, Claude on the web, Cursor, and ChatGPT.

FAQ about scraping NFX Signal investor data

Do I need an NFX account to use this scraper?

No. It reads the public investor lists on signal.nfx.com, so no account, cookie, or token is needed for the source. You only need an Apify token to run the Actor.

Should I build my own scraper for this instead?

If you need one list once, scrape it yourself, it is a fair afternoon of work. The pagination, the stringified cheque amounts, and the firm enrichment chain are the parts that make it a maintenance job rather than a script.

Can I use this scraper from Claude or another AI agent?

Yes, over MCP. Point the client at the server URL above and the agent can discover the input schema and run it, which turns "who invests in my sector" into a live query.

Can I schedule this scraper to run every month?

Yes. Save your input as a Task, attach a Schedule, and diff each run. The monthly tracking example is set up for exactly that.

What does this scraper not give me?

Two honest limits. Not every investor publishes a cheque range, and those fields come back empty rather than estimated. And firm enrichment resolves by company name, so a firm with an ambiguous name may come back without LinkedIn or Crunchbase fields attached; you are not charged for the ones that miss.

More from Truffle Pig Data

This Actor is catalogued on Alpha OSINT alongside the rest of the financial and company data sources.

Try it

Run the NFX Signal Investor API on a single list first, with maxItems set low, and see whether the cheque sizes change how you build your list. That is the part I did not expect to matter as much as it does.

How to Pull Remote Startup Jobs With Salary and Equity in 2026 (Python + a jobs API)

Truffle Pig Data — Thu, 20 Aug 2026 13:05:33 +0000

Pulling remote startup jobs with real salary and equity numbers attached is harder than it should be. Wellfound, the site formerly known as AngelList Talent, is one of the few places where companies publish both right on the posting, which is why I went there to answer what sounded like a simple question: what does a seed-stage startup actually pay a backend engineer?

Reading a few hundred postings by hand is not a research method. So here is the manual approach, where it falls over, and the jobs API I use instead.

Disclosure: the Apify links in this post are affiliate links. If you run the Actor, I may earn a referral commission at no extra cost to you.

What the API returns

The Wellfound Jobs API returns startup job listings as structured JSON, with the posted compensation parsed into separate salary and equity numbers.

Most job feeds hand you a string like $135k - $165k * 0.05% - 0.15% and wish you luck. This one gives you that string and the parsed numbers next to it:

Field	Example	Notes
`compensationRaw`	`$135k – $165k • 0.05% – 0.15%`	exactly as posted
`salaryMin` / `salaryMax`	`135000` / `165000`	parsed, `null` when unpublished
`equityMin` / `equityMax`	`0.05` / `0.15`	percent, `null` when unpublished
`company.ycFunded`	`true`	Y Combinator flag
`company.stage`	`early_stage`	funding stage
`remoteKind`	`REMOTE_ONLY`	remote arrangement
`description`	full markdown	the whole posting

You also get title, url, locationNames, acceptedRemoteLocationNames, jobType, yearsExperienceMin/Max, postedAt, and a company object with size, tagline, and the topInvestors and activelyHiring flags.

Who this is for

You are building a job board or an aggregator and want early-stage roles that the big feeds miss.
You are weighing an offer and want a defensible comp range instead of a vibe.
You are a founder setting a band and have nothing to compare against.

The DIY path, and where it breaks

Wellfound is a Next.js app, so the listing data is sitting in the __NEXT_DATA__ blob rather than the HTML. You can get surprisingly far with requests and a JSON walk:

import json, re, requests

html = requests.get("https://wellfound.com/role/r/software-engineer").text
blob = json.loads(re.search(r'__NEXT_DATA__[^>]*>(.*?)</script>', html, re.S).group(1))
apollo = blob["props"]["pageProps"]["apolloState"]["data"]
jobs = [v for v in apollo.values() if v.get("__typename") == "JobListingSearchResult"]
print(len(jobs), "jobs on page 1")

Three things break this, in the order you hit them:

The compensation is one string. $135k – $165k • 0.05% – 0.15% has to be split into four numbers, and the format varies. Salary only, equity only, hourly, "competitive".
Role slugs are not free text. /role/software is a 404. Only /role/software-engineer exists. You need the real slug list before you can query anything.
The page shapes differ. The role pages use JobListingSearchResult, but the site-wide feed uses a completely different typename with a different nesting. Parse one and the other silently returns nothing.

None of that is unsolvable. It is just a parser you now own forever.

The shortcut: run it as an API

The Wellfound Jobs API handles the parsing, the slug mapping, and both page shapes. Three ways in.

Console. Open the Actor page, click Try for free, set a role, and run it.

REST. Any HTTP client, using the Apify run-sync endpoint:

curl -X POST "https://api.apify.com/v2/acts/johnvc~wellfound-jobs-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"roles":["software-engineer"],"remoteOnly":true,"maxItems":25}'

MCP. It runs as a tool for Claude and other MCP clients. Point your config at:

https://mcp.apify.com/?tools=actors,docs,johnvc/wellfound-jobs-api

Then ask in plain language: "find remote startup jobs for a senior backend engineer paying over 160k, and tell me which companies are YC backed." Setup docs are in the Apify MCP guide.

Find remote startup jobs

The one I reach for most. remoteOnly filters to listings that actually accept remote applicants, and acceptedRemoteLocationNames on each row tells you where they accept them from, which is the part that usually disqualifies you.

{"roles": ["software-engineer"], "remoteOnly": true, "minSalary": 150000, "maxItems": 50}

Ready to run: Find Remote Startup Jobs.

Find Y Combinator startup jobs

ycOnly narrows to YC-backed companies, which is the filter I have not found anywhere else. Pair it with companyStage so you are comparing seed against seed rather than seed against Series C.

{"roles": ["software-engineer"], "ycOnly": true, "includeDescription": false, "maxItems": 150}

Ready to run: Find Y Combinator Startup Jobs.

Startup jobs in San Francisco

locations takes city slugs and pairs with any role. Each role and city combination becomes its own search, so three roles across four cities is twelve searches, not seven. Watch maxItems accordingly.

{"roles": ["product-manager"], "locations": ["san-francisco"], "maxItems": 50}

Ready to run: Find Startup Jobs in San Francisco.

Startup jobs in New York

Same shape, different slug. Worth running separately rather than together, because the comp distributions are genuinely different and averaging across cities hides that.

{"roles": ["data-scientist"], "locations": ["new-york"], "minSalary": 140000, "maxItems": 50}

Ready to run: Find Startup Jobs in New York.

Startup jobs in London

Non-US cities work the same way. Check salaryCurrency on the rows before you compare anything, because a London posting quoting GBP next to a SF posting quoting USD is not a comparison.

{"roles": ["backend-engineer"], "locations": ["london"], "maxItems": 50}

Ready to run: Find Startup Jobs in London.

Get startup salary and equity data

The comp use case, with descriptions off because nobody averages prose. Drop the rows where the field is null before you compute anything, and report how many survived.

rows = [r for r in items if r.get("result_type") == "job"]
with_salary = [r for r in rows if r.get("salaryMin") is not None]
with_equity = [r for r in rows if r.get("equityMin") is not None]
print(f"{len(with_salary)}/{len(rows)} published salary, {len(with_equity)}/{len(rows)} published equity")

On a 30-row YC sample I ran while writing this, 28 published a salary and only 5 published equity. Those are different sample sizes and deserve separate sentences.

Ready to run: Get Startup Salary and Equity Data.

The example repo

johnisanerd / Apify-Wellfound-Jobs-API

Startup jobs API example: pull Wellfound (AngelList) jobs with parsed salary, equity, remote status and YC signals. Python + uv quick start and MCP setup.

💼 Wellfound Jobs API: A Startup Jobs API for Salary and Equity Data

A startup jobs API for Wellfound (formerly AngelList Talent). Search by role, location, and remote status, and get one clean JSON row per job: the full description, parsed salary and equity ranges, and the hiring startup's signals including Y Combinator backing, top investors, and funding stage.

Actor: https://apify.com/johnvc/wellfound-jobs-api?fpr=9n7kx3

Video Walkthrough

Text walkthrough

This jobs API turns Wellfound's public startup listings into structured data. You give it roles (Wellfound slugs like software-engineer, or plain words like "software" and "pm", which are mapped for you) and optionally locations such as san-francisco, new-york, or london. Each role and location pair becomes its own search, and the API walks the paginated results for you.

Every row comes back with title, url, the full markdown description, and compensation parsed into real numbers: salaryMin, salaryMax…

View on GitHub

Python quick start plus MCP setup walkthroughs for Claude Code, Cursor, and ChatGPT.

FAQ about scraping Wellfound jobs

Should I build my own Wellfound scraper or use an API?

Build it if the parser is the interesting part of your problem. Use the API if the data is. The three breakages above are the ones you will spend your time on, and they change without warning.

Can I use this jobs scraper from Claude or another AI agent?

Yes. It runs as an MCP tool at https://mcp.apify.com/?tools=actors,docs,johnvc/wellfound-jobs-api. There are also two open agent skills built on it, linked below.

Can I schedule this scraper to run automatically?

Yes, through Apify Schedules, on any cron you like. Dedupe on url, which is canonical and survives a company editing the job title.

Does the scraper return salary and equity for every job?

No, and this is the honest limitation that matters most. It returns what the company published. Plenty of postings carry neither. Always report your coverage count alongside any figure you quote.

Can the scraper search Wellfound by keyword?

Not site-wide, because Wellfound does not serve a site-wide free-text search. keyword filters the jobs on the pages a run already fetched. Drive the search with roles and locations and use keyword to narrow further.

Wrapping up

If you want the parser, the code above is a fine starting point. If you want the data, the Wellfound Jobs API bills per job returned with no start fee, so a run that matches nothing costs essentially nothing.

Apify Store Scraper: Market Intelligence on Every Public Actor in 2026

Truffle Pig Data — Thu, 20 Aug 2026 12:36:45 +0000

There are thousands of public Actors on the Apify Store, and if you build or buy scrapers, the store itself is a dataset worth having: who charges what, which tools actually get used, and whose runs quietly fail. I wanted that as rows, not browsing. The Apify Store API sweeps every public Actor into flat JSON with pricing, usage trends, and reliability stats.

Disclosure: the Apify links in this post are affiliate links. If you run the Actor, I may earn a referral commission at no extra cost to you.

Doesn't Apify already have an API for this?

Partly, and credit where due: Apify's platform API is excellent for running Actors and lists basic store info. What it does not hand you is the commercial layer as one dataset: 30-day run outcomes split into succeeded, failed, aborted, and timed out, success rates, user trends over 7, 30, and 90 days, per-event pricing detail, and optional README plus input-schema enrichment, one flat row per Actor. Assembling that from public listing pages is exactly the tedious join this Actor does for you, with no platform key or subscription required.

What the Apify Store API returns

The Apify Store API returns one flat JSON row per public Actor with identity, usage, reliability, demand, and pricing fields ready for a spreadsheet or database.

Field	Example	Notes
`name` / `username`	`instagram-scraper` / `apify`	With `title`, `url`, `categories`
`totalUsers`	`512340`	Plus `monthlyUsers` and 7, 30, 90-day trends
`successRate30Days`	`96.0`	With full run-outcome breakdowns
`reviewRating`	`4.6`	And `reviewCount`, `bookmarkCount`
`pricingModel`	`PRICE_PER_DATASET_ITEM`	With `pricePerUnitUsd` and pricing events
`readme`	full text	Optional, via `includeDetails`

Filter by search, category, pricingModel, or username, or leave filters empty and sweep the whole store.

Who this is for

Actor developers scoping a niche before building, which is how I use it: is the category crowded, what does the incumbent charge, does it actually succeed. Developers choosing a scraper to depend on, where successRate30Days beats marketing copy. And analysts studying the web-scraping market with actual usage numbers.

The manual way, and where it breaks

You can research the store by clicking through listings and noting stats in a sheet. It works for five Actors. At fifty, the numbers you copied first are stale, the pricing models refuse to compare cleanly, and you have no reliability data at all unless you check each card again tomorrow. Store pages are built for browsing; questions like "every LinkedIn scraper sorted by 30-day success rate" need a dataset.

The faster way: run the Apify Store scraper

Apify Console

Open the Apify Store API and click Try for free.
Set a search term or category, or leave both empty for a full sweep, and cap with maxItems.
Run it and export the rows as JSON, CSV, or Excel.

REST

curl -X POST "https://api.apify.com/v2/acts/johnvc~store-actor-intelligence-api/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "search": "google maps", "sortBy": "popularity", "maxItems": 100 }'

Endpoint reference: the Apify API docs.

Rank a category in Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("johnvc/store-actor-intelligence-api").call(
    run_input={"search": "google maps", "sortBy": "popularity", "maxItems": 100}
)

for actor in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(actor["name"], actor.get("monthlyUsers"), actor.get("successRate30Days"), actor.get("pricingModel"))

Two lines of pandas later you have a league table.

Find the best scraper for any site

The Actor ships with ready-made "best scrapers" tasks per category, each returning the ranked field with usage and reliability attached: best Google Maps scrapers, best Amazon scrapers, best LinkedIn scrapers, and best YouTube scrapers, with dozens more on the Actor's examples tab.

Shortlist Actors by audience

Role-based variants do the same for a persona instead of a site: best Actors for developers, for marketers, for recruiters, and for ecommerce sellers.

Let Claude compare scrapers over MCP

Through the Model Context Protocol, Claude, Claude Code, and Cursor can call the Actor as a tool, so "which Instagram scraper has the best 30-day success rate under a cent per result" becomes a grounded, current answer. More on Claude at claude.ai.

FAQ about scraping the Apify Store

Why use a scraper when Apify has an official API?

The official API is built for running Actors, not for market analysis of the store. This scraper flattens the public commercial signals, usage trends, run outcomes, pricing detail, into one row per Actor, which is the shape competitive questions need.

What does the Apify Store scraper cost?

You pay per Actor returned on pay-per-event billing, no subscription and no upstream key, and the per-result price is set to make even a full-store sweep cheap. The live rate is on the Store card, and maxItems caps any run.

How do I pick a reliable scraper from the output?

Sort on successRate30Days first, then sanity-check monthlyUsers and lastRunStartedAt. A tool with high success, active users, and a recent run is maintained; a pretty README with a 60 percent success rate is a warning.

Can Claude run this Store scraper through MCP?

Yes. Expose it via the Apify MCP server and it becomes a callable tool in Claude, Claude Code, Cursor, or any MCP client, useful for agent workflows that need to choose tools with evidence.

Can I schedule the scraper to track a niche weekly?

That is the intended pattern for competitor tracking: save your filter as a task, attach an Apify schedule, and diff usage and pricing across runs. Start from the Apify Store API.

What does the scraper leave out?

Anything not on public listings: private Actors, unpublished drafts, and internal revenue numbers do not exist in the output. Public stats are the whole universe, which is plenty for ranking but not a P&L.

More from Truffle Pig Data

The same sweep works on other catalogs: the RapidAPI Marketplace API does it for API listings, Apple App Store Search for mobile apps, and the G2 Reviews API adds buyer sentiment for the software behind the listings.

Wrapping up

The store is a market, and markets reward whoever has the data. Sweep it once with the Apify Store API and see your category with the numbers attached.

SEC EDGAR API for Developers: Parsed 8-K Filings and Earnings Call Transcripts in 2026

Truffle Pig Data — Thu, 20 Aug 2026 12:28:11 +0000

Every 8-K a US public company files lands on SEC EDGAR within minutes, and every earnings call gets transcribed somewhere. Turning either into analyzable data is the grind: EDGAR hands you raw HTML filings, and transcripts live scattered across sites that hate being parsed. This post covers what the free official route gives you, where it stops, and the shortcut: the Earnings Call Transcript API on Apify, which returns parsed 8-Ks and speaker-tagged transcripts as JSON records.

Disclosure: the Apify links in this post are affiliate links. If you run the Actor, I may earn a referral commission at no extra cost to you.

Standard note for anything finance-shaped: this is a data tool. Nothing here is investment advice.

Doesn't SEC EDGAR already have an API?

It does, and it is genuinely free: EDGAR offers full-text search and per-company submission feeds, no key required. What it returns is raw. An 8-K arrives as a filing envelope full of HTML, with the item codes, press release, and guidance language buried inside for you to parse. And earnings call transcripts are not in EDGAR at all, since companies rarely file them. The gap is structure: something that reads the filing for you, tags the items, pulls the guidance sentences, and pairs each call's questions with their answers. That parsing layer is what this Actor sells; the underlying documents were always free.

What the Earnings Call Transcript API returns

The Earnings Call Transcript API returns two record types as structured JSON: parsed 8-K filings with item codes, press releases, guidance sentences, and sentiment, and earnings call transcripts with participants, prepared remarks, and Q&A pairs.

Field	Example	Notes
`recordType`	`filing`	Or `transcript`
`itemCodes` / `itemNames`	`["2.02", "9.01"]`	What the 8-K actually announces
`pressRelease`	`{ "headline": "Apple reports second quarter results" }`	Extracted from the filing
`guidanceSentences`	`"We expect June quarter revenue to grow..."`	Forward-looking language, isolated
`qaPairs`	`{ "question": { "speaker": "Erik Woodring", "affiliation": "Morgan Stanley" }, "answers": [...] }`	Analyst question matched to executive answers
`sentiment`	`{ "positive": 18.94, "negative": 16.57, "netScore": 0.067 }`	Deterministic finance-dictionary scoring

Every record links back to its source with EDGAR url and documentUrl fields, so claims stay checkable.

Who this is for

Data engineers building event feeds off itemCodes instead of regex. Fintech and AI builders who want qaPairs as a clean corpus for LLM and RAG work. And analysts who screen disclosures, material weakness, going concern, guidance withdrawals, across every US filer with a keyword instead of a browser.

The manual way, and where it breaks

I have written the DIY version: hit the EDGAR feeds, download each 8-K, and parse item codes out of HTML that formats differently per filer. It works until a filing arrives with exhibits arranged some new way, and then your parser silently mislabels events. Transcripts are worse, since there is no official source to parse at all, just third-party pages with their own layouts and access rules. Each piece is a solvable weekend project; keeping both alive across thousands of filers is a job.

The faster way: run the earnings call scraper

Apify Console

Open the Earnings Call Transcript API and click Try for free.
Enter tickers and pick a dataType: filings, transcripts, or both.
Run it and export the records as JSON, CSV, or Excel.

REST

curl -X POST "https://api.apify.com/v2/acts/johnvc~earnings-call-transcript-api/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "tickers": ["AAPL"], "dataType": "both", "filingsLimit": 5, "transcriptsLimit": 1 }'

Details in the Apify API docs.

Parse filings and transcripts in Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("johnvc/earnings-call-transcript-api").call(
    run_input={"tickers": ["AAPL"], "dataType": "both", "transcriptsLimit": 1}
)

for rec in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(rec["recordType"], rec["ticker"], rec.get("title"))
    for sentence in rec.get("guidanceSentences", [])[:3]:
        print("  guidance:", sentence)

Grab a ticker's earnings call transcript

There is a ready-made task per major ticker, each returning the speaker-tagged call in JSON: AAPL, NVDA, TSLA, and MSFT, with more on the Actor's examples tab.

Pull parsed 8-Ks by ticker

The filings surface on its own: SEC EDGAR 8-K filings API by ticker returns recent filings per company, and 8-K item codes, guidance, and sentiment shows the parsed structure in full.

Screen EDGAR for red-flag language

Full-text keyword search across all US filers powers the screener tasks: material weakness disclosures, going concern warnings, guidance withdrawals, and financial restatements.

Monitor material events as a feed

With onlyNew set, scheduled runs return only fresh records, which turns item-code filters into event trackers: material events watchlist, cybersecurity incidents under Item 1.05, and executive departures under Item 5.02.

Build an LLM dataset from Q&A pairs

Because qaPairs ships pre-matched, the task Earnings call Q&A dataset for LLM and RAG produces a training-ready corpus, and Earnings guidance monitor does the same for forward-looking statements.

Query filings from Claude over MCP

Through the Model Context Protocol, Claude, Claude Code, and Cursor can call the Actor mid-conversation, so "summarize Apple's latest 8-K and its guidance language" runs against the actual filing. You can read more about Claude at claude.ai.

FAQ about scraping earnings calls and SEC filings

EDGAR is free, so why pay for a scraper at all?

Because EDGAR returns documents and this scraper returns data. You are paying for the parsing: item codes tagged, press releases extracted, guidance sentences isolated, Q&A matched to speakers, plus transcripts that EDGAR never had.

What does the earnings call scraper cost per record?

One event per record returned, a parsed filing or a structured transcript, with no start fee. One hundred records cost about a cent, so a quarterly refresh of a 50-ticker watchlist runs about that.

What does a transcript from the scraper include?

Participants with roles, prepared remarks tagged by speaker, analyst questions paired with executive answers, guidance sentences, and a sentiment score. No audio, and typically available within hours of the call.

Can Claude run this scraper through MCP?

Yes. Connect the Apify MCP server and the Actor becomes a callable tool, which makes filings and transcripts available to an agent as grounded context instead of recall.

Can I schedule the scraper to watch for new 8-Ks?

That is what onlyNew is for. Save a task with your tickers or item codes, attach an Apify schedule, and each run returns only records you have not seen. Start from the Earnings Call Transcript API.

Where does the scraper's coverage end?

Transcripts cover roughly 1,000 to 1,500 mostly large and mid cap US companies per quarter, with an archive back to about 2007, so thin micro caps may have filings but no call. Sentiment comes from a deterministic finance dictionary rather than an LLM, and there are no 10-K or 10-Q statements and no XBRL fundamentals here.

More from Truffle Pig Data

Event data pairs naturally with prices and context: the Google Finance API adds live quotes and financial statements, the Congress Financial Disclosures API tracks another primary-source signal, and the Crunchbase Company API fills in firmographics for the same names.

Wrapping up

The filings were always public; the structure was the missing part. Point the Earnings Call Transcript API at your watchlist and get 8-Ks and calls back as records you can actually compute on.

Reputation Research on Google Maps: Spot Out-of-Town Reviewers with Public Data in 2026

Truffle Pig Data — Wed, 19 Aug 2026 08:11:04 +0000

A suspicious one-star review usually raises the same question: is this person even local? The review history behind any Google Maps contributor profile is public, but it reads as an endless scroll of place names, not an answer. I'll show the manual way to read that footprint, why it does not scale, and the shortcut: the Google Maps Reviewer Geo Profile API on Apify, which clusters a reviewer's public review locations into a region-level home estimate with a confidence score.

Disclosure: the Apify links in this post are affiliate links. If you run the Actor, I may earn a referral commission at no extra cost to you.

Is there an API for Google Maps reviewer activity?

Google's official APIs return a few reviews per place, but nothing per reviewer: no endpoint accepts a contributor and returns where they review. The public contributor page shows the history, one scroll at a time, in whatever language each review was written. This Actor reads that public history and adds the analysis you would otherwise build yourself: reverse geocoding against an offline GeoNames dataset, then spatial clustering into a standardized home-region estimate.

What the Reviewer Geo Profile API returns

The Reviewer Geo Profile API returns one derived row per reviewer: a standardized home-region guess with ISO codes, a confidence score, home-versus-travel review counts, a regional footprint, and centroid plus bounding-box geometry.

Data point	Example	Notes
Home-region guess	Chicago, Illinois, US	standardized names plus ISO codes
Confidence score	0.86	cluster-based, how dominant the home cluster is
Home vs travel counts	61 home, 14 travel	separates the base cluster from outliers
Regional footprint	top regions with counts and shares	a compact travel map
Geometry	centroid and bounding box	ready for plotting
Reviewer metadata	public profile basics	for context

Who this is for

Trust-and-safety and review-fraud analysts, businesses vetting a reviewer's footprint before responding or escalating a dispute, and researchers doing reputation research across batches of reviewers for the same place.

The manual way, and where it breaks

By hand, you open the contributor profile, scroll until it stops loading, note each reviewed place, and look up where those places are. An active reviewer has hundreds of reviews, the place names arrive unstandardized, and "Chicago Loop" and "Chicago" read as different locations unless you normalize them yourself. You end up with a hand-built map, a gut feeling, no confidence number, and an hour gone per reviewer.

The faster way: run the Google Maps Reviewer Geo Profile API

Apify Console

Open the Google Maps Reviewer Geo Profile API and click Try for free.
Paste a contributor ID, the long numeric ID in a reviewer's profile URL.
Run it and export; one derived row per reviewer.

REST

curl -X POST "https://api.apify.com/v2/acts/johnvc~google-maps-reviewer-geo-profile-api/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "contributorId": "107022004965696773221" }'

Endpoint mechanics are in the Apify API docs. Two knobs matter: regionGranularity sets whether the guess lands at city, state, or country level, and minCityPopulation snaps metro neighborhoods under their principal city.

Profile reviewers in Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("johnvc/google-maps-reviewer-geo-profile-api").call(
    run_input={
        "contributorIds": ["107022004965696773221"],
        "regionGranularity": "city",
        "maxResultsPerContributor": 100,
    }
)

for profile in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(profile)

Read the home-region guess and its confidence first, then the home-versus-travel split; together they tell you whether a footprint looks locally coherent.

Bulk-analyze reviewer home regions

Bulk analyze Google reviewers home regions runs a list of contributor IDs and returns one row each; it is also published in Russian and Chinese.

Detect out-of-town reviewers

Detect out of town Google reviewers flags reviewers whose home cluster sits nowhere near the business being reviewed (Russian, Chinese).

Find a reviewer's home country

Find a Google reviewer's home country sets the granularity to country for the coarse view (Russian, Chinese).

Spot geographically inconsistent reviewers

Spot geographically inconsistent reviewers surfaces footprints too scattered to be one person's normal life, the classic fraud-research signal (Russian, Chinese).

Verify a reviewer is a real local

Verify a Google reviewer is a real local is the positive case: confirm a champion is genuinely local before featuring their review (Russian, Chinese).

Use it from Claude via MCP

Through the Apify MCP server, Claude, Claude Code, or Cursor can take a contributor ID from a review you are discussing and return the geo profile mid-conversation. The setup lives in Profile a Google reviewer's location via MCP (Russian, Chinese), and Claude itself is at claude.ai.

FAQ about scraping Google Maps reviewer data

Is it OK to run a scraper on a reviewer's profile?

The Actor reads only public review history, the same pages anyone can open in a browser, and outputs a region-level aggregate rather than an address. It exists for business analytics: review-fraud research, reviewer vetting, and reputation research on public activity. Use it for that, not for anything aimed at individuals.

What does the reviewer geo scraper cost?

Two cents per contributor analyzed on the free tier, plus a fraction of a cent per run to start. Depth is included: profiling 200 reviews of history costs the same per reviewer as 50.

How accurate is the scraper's home-region estimate?

It is an inference, and the output says so. The densest review cluster stands in for a base location, with a confidence score attached; travel-heavy accounts blur the signal, and deeper history, up to 200 reviews, sharpens it. I treat it as a research signal, never as a verified location.

Can Claude call this scraper over MCP?

Yes, the Actor registers as an MCP tool, so agents in Claude, Claude Code, and Cursor can profile a contributor ID on demand.

Can I schedule the scraper to re-check reviewers?

Yes: save the ID list as a task and schedule it monthly to watch for changes in geographic coherence over time. Start from the Google Maps Reviewer Geo Profile API.

More from Truffle Pig Data

This pairs naturally with the Google Maps Contributor Reviews API, which pulls the raw review history the analysis is built on, plus the Google Maps Places API for place details and the Google Local API for local listings.

Wrapping up

Where a reviewer actually reviews is public signal; it just needed structure and a confidence score. Run one contributor ID through the Google Maps Reviewer Geo Profile API and read the row for yourself.

SKU Tracking with Google Shopping: Bulk Price Monitoring at $1.50 per 1,000 Products

Truffle Pig Data — Tue, 18 Aug 2026 19:09:43 +0000

Price monitoring is a volume game. Watching one product is trivial; watching five hundred SKUs across every retailer Google Shopping indexes, daily, is where tooling either gets expensive or gets built. I built the Google Shopping Lite API for exactly that middle path: send a batch of search terms, get one flat JSON row per product with price, retailer, rating, delivery, and link, at $1.50 per 1,000 products.

Disclosure: the Apify links in this post are affiliate links. If you run the Actor, I may earn a referral commission at no extra cost to you.

Is there a Google Shopping API?

Not for reading the marketplace. Google's official shopping APIs exist to manage your own merchant listings, which is the opposite direction: you push your products in, you don't query what everyone else charges. There's no public endpoint for "show me every retailer selling this SKU and their prices." That query is exactly what competitive pricing work needs, so the practical answer is a scraper consumed as an API: search terms in, product rows out.

What the Google Shopping Lite API returns

The Google Shopping Lite API returns one structured row per product: title, price, retailer, rating, delivery info, and the product link.

Field	Example	Notes
Title	`Sony WH-1000XM5 Wireless Headphones`	Product name as listed
Price	`$328.00`	Localized to the country you target
Retailer	`Best Buy`	Who's selling at that price
Rating	`4.7`	Star rating when shown
Delivery	`Free delivery`	Shipping line as displayed
Link	`https://...`	Route to the offer

Each search term returns roughly 40 to 60 products per page, and maxResultsPerSearch caps how deep each term goes. The "Lite" in the name is the point: no nested page structures, just rows you can load straight into a dataframe or a spreadsheet.

Who this is for

E-commerce operators doing SKU tracking against competitors. Dropshipping researchers scanning what a niche actually sells for before committing inventory. Analysts building price indexes across retailers. And anyone wiring price checks into AI agent workflows, where an agent needs current numbers instead of its training data's memory of them.

The manual way, and where it breaks

Google Shopping in a browser is pleasant; Google Shopping in a script is hostile. Results render through JavaScript, layouts rotate between grid variants, prices arrive in localized formats you have to normalize, and sustained automated traffic gets you a captcha. The real killer for bulk work is multiplication: 500 search terms times retries times proxy rotation is an infrastructure bill and an on-call rotation. For a one-off market check, fine, suffer through it. For monitoring, you want the parser to be someone else's standing problem. Mine, as it happens.

The faster way: run the Google Shopping Lite API

Apify Console

Open the Google Shopping Lite API and click Try for free.
Add your searchTerms list and pick a country.
Run it and export rows as JSON or CSV.

REST

curl -X POST "https://api.apify.com/v2/acts/johnvc~google-shopping-lite-api/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "searchTerms": ["wireless headphones", "noise cancelling earbuds"], "country": "us", "maxResultsPerSearch": 50 }'

Full endpoint reference in the Apify API docs.

Bulk price pulls in Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("johnvc/google-shopping-lite-api").call(
    run_input={
        "searchTerms": ["lego technic 42143", "lego icons 10311"],
        "country": "us",
        "maxResultsPerSearch": 40,
    }
)

for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(product.get("price"), product.get("retailer"), product.get("title"))

Search by SKU-specific terms like model numbers and the rows map cleanly onto your catalog.

Monitor competitor prices

The task Monitor competitor prices on Google Shopping is the core commercial setup: your product terms, on repeat, diffed between runs.

Compare prices across retailers

Compare product prices on Google Shopping answers the single-product question, who sells it and for how much, in one run.

Export a whole category

Bulk export Google Shopping prices shows the many-terms pattern that ends in one CSV, useful for market sizing and assortment research.

Track a niche over time

Two hobbyist-flavored examples double as templates for any niche: track game console prices and track LEGO set prices in bulk. Swap the terms and the same tasks track GPUs or sneakers.

For cross-border sellers

Two Chinese-language tasks serve cross-border e-commerce teams: Google Shopping price comparison for product selection and bulk competitor price monitoring, both using the country and language inputs to read a target market from outside it.

Price checks inside AI agent workflows

Over the Model Context Protocol, the Actor becomes a tool for Claude, Claude Code, and Cursor, so "what's the cheapest current price for this model and who sells it" gets answered with live rows mid-conversation. The task Compare product prices in Claude via a shopping MCP has the configuration, and you can read more about Claude at claude.ai.

FAQ about Google Shopping scraping

What does the shopping scraper cost at scale?

$1.50 per 1,000 products, billed per product returned, plus a negligible start fee. A 500-term sweep at 40 products each is 20,000 rows, about $30. maxResultsPerSearch is your budget dial, and free Apify credit covers first experiments.

How is this Lite scraper different from the full Google Shopping API Actor?

Lite trades depth for speed and unit cost: one flat row per product, minimal fields, priced for bulk. The full Google Shopping API covers products, prices, and deals in richer structures when you need more than the price row.

Can Claude call this scraper in an agent workflow?

Yes. Registered through Apify's MCP server it's a callable tool in Claude, Claude Code, and Cursor, which is the cleanest way to give an agent live price data.

How do I schedule the scraper for daily SKU tracking?

Save your term list as a task, attach an Apify schedule, and each run appends dated rows so price history accumulates automatically. Start from the Google Shopping Lite API.

What won't a search-results scraper capture?

Anything deeper than the results page: full spec sheets, seller stock levels, or historical prices Google doesn't display. Matching returned rows to your exact SKUs is also on you, which is why model-number search terms beat generic ones.

More from Truffle Pig Data

Neighboring Actors for commerce data: the full Google Shopping API for deal-level detail, the Google Immersive Product API for Google's immersive product panels, and the Google Local API when the competition is local stores rather than online carts.

Wrapping up

SKU tracking shouldn't cost more than the margin it protects. At $1.50 per 1,000 products, the Google Shopping Lite API makes daily price visibility a rounding error; start with your ten most contested SKUs.

Google Autocomplete API: Turn Type-Ahead Suggestions into JSON in 2026 (Python, MCP, No-Code)

Truffle Pig Data — Tue, 18 Aug 2026 08:10:50 +0000

Type half a query into Google and the dropdown finishes your sentence: ranked, localized, and drawn from what people actually search. I think of it as Google publishing its own query logs, ten lines at a time, and there is no clean official way to collect it. This post covers the DIY route, its potholes, and the Google Autocomplete API on Apify, which returns the ranked suggestion list for any batch of partial queries as JSON.

Disclosure: the Apify links in this post are affiliate links. If you run the Actor, I may earn a referral commission at no extra cost to you.

Is there an official Google Autocomplete API?

Not for web search. Google Maps Platform sells Places Autocomplete, which completes place names inside a maps product, and that is a different job. For general search suggestions there is only an undocumented endpoint that returns quirky JSONP, throttles you at volume, and can change any day. So in practice a Google Autocomplete API means a scraper consumed as an API: partial queries in, ranked suggestions out.

What the Google Autocomplete API returns

The Google Autocomplete API returns the ranked suggestion list for each partial query as structured JSON: one record per suggestion, linking the source query, the suggestion's rank, and the suggested text, localized by country and language.

Data point	Example	Notes
Input query	coffee near	the partial query you sent
Suggested text	coffee near me open now	one record per suggestion
Rank	1	position in the dropdown
Country (`gl`)	us	two-letter localization code
Language (`hl`)	en	interface language for suggestions

Who this is for

SEO and PPC people expanding seed keywords into real phrases, builders resolving vague place queries before a Maps or Places lookup, and agent developers who want autocomplete as a disambiguation tool.

The manual way, and where it breaks

Manual collection is an incognito window and a spreadsheet: type each seed, transcribe ten suggestions, switch your VPN to change country, repeat. The script version hits the unofficial suggest endpoint, and it works right up until it does not: undocumented parameters, JSONP wrappers to strip, localization that follows your IP instead of your settings, and throttling once you send real volume. Neither version leaves you with anything stable enough to build on.

The faster way: run the Google Autocomplete API

Apify Console

Open the Google Autocomplete API and click Try for free.
Add partial queries under queries, like coffee near, and set gl and hl if you want another market.
Run it and export the suggestions as JSON or CSV.

REST

curl -X POST "https://api.apify.com/v2/acts/johnvc~google-autocomplete-api/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "queries": ["coffee near"], "gl": "us", "hl": "en" }'

Full endpoint reference: the Apify API docs.

Expand keywords in Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("johnvc/google-autocomplete-api").call(
    run_input={
        "queries": ["coffee near", "best pizza in"],
        "gl": "us",
        "hl": "en",
    }
)

for suggestion in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(suggestion)

Every record ties back to its input query with a rank, so grouping by seed and sorting by rank rebuilds each dropdown exactly.

Get suggestions for any keyword

Get Google search suggestions for any keyword is the plain starting point: one seed, the ranked list back.

Mine long-tail keyword ideas

Get long tail keyword ideas from Google autocomplete expands seeds into the specific phrases people type, which is where low-competition content lives.

Pull question keywords

Get question keywords from Google autocomplete harvests question-format phrases, ready-made for FAQ sections and content planning.

Find negative keywords for Google Ads

Find negative keywords for Google Ads surfaces suggestions that reveal intents you do not want to pay for, like free, cheap, or DIY variants.

Keyword research data as JSON

Get keyword research data as JSON from Google is the spreadsheet-ready version of the whole loop.

It speaks Chinese too

Google search suggestions in Chinese and Chinese long-tail keywords run the same pattern for Chinese-language markets.

Use it from Claude via MCP

Ask Claude what people search after "best crm for" and, with the Actor connected as an MCP tool through Apify, it fetches the live list instead of guessing. The same tool works in Claude Code and Cursor for agent-driven query expansion, and claude.ai is where to pick up Claude if you need it.

FAQ about scraping Google Autocomplete

How much does the Google Autocomplete scraper cost, and is anything free?

Billing is 0.2 cents per suggestion returned on the free tier, so a seed returning ten suggestions costs about two cents. New Apify accounts carry free platform credit, which means early keyword batches usually cost nothing out of pocket.

Why not scrape Google's suggest endpoint myself instead of using a hosted scraper?

For a weekend test, go ahead; that endpoint is how many of us started. For anything recurring you inherit undocumented parameters, response-format changes, and throttling, and the hosted version trades a fraction of a cent per suggestion for never owning that.

Can the scraper localize suggestions by country and language?

Yes: gl sets the country and hl the language for each run, so you can pull the same seeds for the US, Germany, and Japan and diff the dropdowns.

Does the scraper work as an MCP tool in Claude or Cursor?

Yes, via the Apify MCP server it registers as a callable tool, which turns autocomplete into a live lookup step inside agent workflows.

Can I schedule the scraper to keep keyword lists fresh?

Yes, recurring runs are the intended pattern: schedule a task with your seed list and accumulate suggestion history for trend analysis. Set it up from the Google Autocomplete API.

What won't an autocomplete scraper tell you?

Search volume or difficulty. A suggestion means Google predicts the phrase, not how often people search it, so pair the output with a volume source before betting a content calendar on it.

More from Truffle Pig Data

Adjacent search-data Actors: the Google AI Overview API for what Google's AI answers say, the Google Forums Search API for discussion results, and the DuckDuckGo SERP Scraper for rankings on the private-search side.

Wrapping up

The dropdown was always the most honest keyword data Google shows; now it exports. Feed a few seeds to the Google Autocomplete API and see what your customers type.

Customer Sentiment from G2 Reviews: Scrape B2B Software Feedback as JSON in 2026

Truffle Pig Data — Mon, 17 Aug 2026 19:09:25 +0000

B2B software decisions get argued out in public on G2, in tens of thousands of structured reviews with ratings, roles, and company sizes attached. For anyone doing competitive intelligence or tracking customer sentiment, that corpus is gold, and it only exists as web pages. This post covers the manual route, why scripting it yourself hurts, and the shortcut: the G2 Reviews API on Apify, which turns product URLs into one JSON row per review.

Disclosure: the Apify links in this post are affiliate links. If you run the Actor, I may earn a referral commission at no extra cost to you.

Does G2 have an API?

Not one you can just sign up for. G2's official data access is aimed at vendors and partners under commercial agreements, so an independent developer or analyst who wants review data has no self-serve endpoint. The practical alternative is a scraper you call like an API: send G2 product review URLs, get the public reviews back as structured JSON, capped and sorted the way you asked.

What the G2 Reviews API returns

The G2 Reviews API returns each public review as a JSON row with rating, title, full text, pros and cons, reviewer role, company size, date, and a verified flag.

Field	Example	Notes
`productName`	`Asana`	The product reviewed
`rating`	`4.5`	0 to 5
`pros` / `cons`	`"The interface is simple enough to learn quickly."`	Best-effort split from the review body
`reviewerRole`	`Program Manager`	When disclosed
`companySize`	`Small-Business (50 or fewer emp.)`	G2's size band
`verified`	`true`	Derived from tags like "Validated Reviewer"

Flip includeProductMetadata on and each product adds a metadata row with category, overall star rating, review count, vendor, and named competitors.

Who this is for

Product marketers doing competitor analysis who want rivals' cons as a spreadsheet column. Product and CS teams measuring customer sentiment by role and company size instead of vibes. And buyers or analysts comparing tools on evidence, with the incentivized-review tags visible instead of hidden.

The manual way, and where it breaks

Reading G2 reviews in a browser is fine until you need counts. Copy-paste dies within a page. Scripting against the site directly means JavaScript rendering, aggressive anti-bot friction, and review bodies scattered across question-and-answer fragments you have to reassemble per review. G2 also updates its markup often enough that a homemade parser needs regular surgery. I gave my version two rewrites before concluding the maintenance was the product.

The faster way: run the G2 reviews scraper

Apify Console

Open the G2 Reviews API and click Try for free.
Paste one or more productUrls like https://www.g2.com/products/asana/reviews, set maxReviewsPerProduct and sortBy.
Run it and export the reviews as JSON, CSV, or Excel.

REST

curl -X POST "https://api.apify.com/v2/acts/johnvc~g2-reviews-api/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "productUrls": ["https://www.g2.com/products/asana/reviews"], "maxReviewsPerProduct": 100, "sortBy": "recent" }'

Run mechanics are in the Apify API docs.

Analyze reviews in Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("johnvc/g2-reviews-api").call(
    run_input={
        "productUrls": ["https://www.g2.com/products/asana/reviews"],
        "maxReviewsPerProduct": 50,
        "sortBy": "recent",
    }
)

for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(review["rating"], review.get("reviewerRole"), review.get("cons"))

Filter on companySize and you have sentiment segmented by market tier in a dozen lines.

Use case: benchmark a competitor's cons

Run your product and two rivals in one productUrls list, sorted by recent, and pull only the cons column. The result is a live list of what users dislike about each tool, in their words, segmented by reviewer role. Feed it to an LLM for theme clustering and you have a competitive brief that updates whenever you rerun the input, which beats quarterly analyst decks on both freshness and price.

Use case: watch customer sentiment move after a launch

Sort by recent, cap at the last hundred reviews, and score rating over datePublished weekly. A pricing change or a rough release shows up in the trend line within weeks, with verified and the incentivized tags letting you weight reviews honestly. Because the input is just a saved task, the whole pipeline is a schedule plus a chart.

Read G2 from Claude over MCP

Exposed through the Model Context Protocol, the Actor becomes a callable tool in Claude, Claude Code, and Cursor, so "summarize the recent cons for Asana from small-business reviewers" runs a live pull instead of quoting stale training data. You can read more about Claude at claude.ai.

FAQ about scraping G2 reviews

Is there an official G2 API, or is a scraper the only route?

Official access exists for vendors and partners under agreements, not as a public developer API. For everyone else, a scraper against the public review pages is the workable path, and this one packages it with API ergonomics.

What does the G2 reviews scraper cost to run?

Billing is per review returned, with no per-run setup fee, plus an optional $0.003 per product when includeProductMetadata is on. The current per-review price sits on the Store card, and maxReviewsPerProduct caps spend before you start.

How do I do competitor analysis with this scraper?

Put your competitors' review URLs in one run, sort by recent, and compare pros, cons, and rating trends side by side. The optional metadata row even lists each product's named competitors, which is a handy expansion seed.

Can Claude or another agent drive the scraper over MCP?

Yes. Connect the Apify MCP server and the Actor appears as a tool in any MCP client, which makes live review pulls available inside agent workflows.

Can I schedule the scraper to monitor reviews?

Review monitoring is the intended recurring use: save your product list as a task, attach an Apify schedule, and each run appends the newest reviews for diffing. Start from the G2 Reviews API.

What are the scraper's honest limits?

It returns what the public pages show: products with few reviews yield few rows, reviewer names and roles appear only when disclosed, and the pros and cons split is best-effort parsing of G2's Q&A format. Incentivized reviews are labeled, not laundered.

More from Truffle Pig Data

Vendor intelligence has more than one axis: the Glassdoor Reviews API shows how the same companies treat employees, and the Crunchbase Company API adds funding and firmographics behind the products.

Wrapping up

The software market reviews itself in public; the only missing piece was machine-readable access. Point the G2 Reviews API at a product page and start counting what people actually say.

Glassdoor API in 2026: Scrape Company Reviews into Clean JSON

Truffle Pig Data — Mon, 17 Aug 2026 08:10:47 +0000

Employee reviews on Glassdoor are the closest thing we have to ground truth on what working somewhere is like, and they are locked inside a page built for reading, not analysis. If you want pros, cons, and per-category ratings across a few hundred reviews, you need them as rows, not paragraphs. This post walks the DIY route and then the shortcut: the Glassdoor Reviews API on Apify, which takes company review URLs and returns each review as structured JSON.

Disclosure: the Apify links in this post are affiliate links. If you run the Actor, I may earn a referral commission at no extra cost to you.

Does Glassdoor have an API?

Effectively no. Glassdoor once ran a partner API, but it is closed to new developers, which is why a search for "glassdoor api" turns up forum threads and scrapers rather than a signup page. If you need review data today, the practical route is a scraper you call like an API: send a company review URL, get the reviews back as JSON, capped and filtered the way an endpoint would do it.

What the Glassdoor Reviews API returns

The Glassdoor Reviews API returns one JSON row per employee review with the rating, summary, pros, cons, employment details, and date, plus a per-category ratings breakdown view.

Field	Example	Notes
`companyName`	`Google`	With the source `companyUrl`
`overallRating`	`4`	Per review, 1 to 5
`pros` / `cons`	`"Great company to be at"`	The review text, split
`employmentType`	`Former employee`	With `employmentStatus` like `CONTRACT`
`datePublished`	`2026-07-05T00:00:00.000Z`	Feeds the `days` filter
`ratingWorkLife`	`4`	Breakdown view, with `ratingCultureValues`, `ratingSeniorLeadership`, and more

The breakdown view carries category ratings for career opportunities, compensation, culture, work-life balance, leadership, and diversity, which is where the analyzable signal lives.

Who this is for

Employer-brand and HR teams tracking employer reputation against competitors. People-analytics folks running employee sentiment analysis over review text. And recruiters or diligence analysts who want workplace ratings for a shortlist of companies without reading five hundred reviews by hand.

The manual way, and where it breaks

Reading reviews in a browser works until the question becomes quantitative: has work-life balance sentiment moved since the layoffs? Copying reviews into a sheet does not scale past a page or two. Scripting against the site is a fight, since review pages render through JavaScript, pagination hides behind dynamic requests, and anti-bot pressure on Glassdoor is heavier than on most sites. Every layout change resets your progress. This is the category of scraper I least enjoy maintaining, which is exactly why I run it as a service.

The faster way: run the Glassdoor scraper

Apify Console

Open the Glassdoor Reviews API and click Try for free.
Paste one or more company review URLs into companyUrls, set maxReviewsPerCompany and days.
Run it and export the reviews as JSON, CSV, or Excel.

REST

curl -X POST "https://api.apify.com/v2/acts/johnvc~glassdoor-reviews-api/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "companyUrls": ["https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm"], "maxReviewsPerCompany": 100, "days": 30 }'

Endpoint details: the Apify API docs.

Pull reviews in Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("johnvc/glassdoor-reviews-api").call(
    run_input={
        "companyUrls": ["https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm"],
        "maxReviewsPerCompany": 50,
        "days": 90,
    }
)

for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(review.get("overallRating"), review.get("employmentType"), review.get("pros"))

A ready-to-run copy lives in the task Glassdoor Reviews API in Python.

Export reviews to JSON by company URL

The base recipe, one URL in and clean rows out, is the task Scrape Glassdoor reviews to JSON.

Analyze employee sentiment

Feed the pros and cons text into your sentiment pipeline or an LLM and score themes over time. The starting point is Employee sentiment from Glassdoor reviews.

Break ratings down by category

Work-life, compensation, leadership, and culture arrive as separate numbers per company in the breakdown view: Glassdoor ratings breakdown by category.

Benchmark employer reputation

Run several competitors in one input and compare their category ratings side by side, per the task Employer reputation from Glassdoor.

Monitor new reviews on a schedule

With days set to your cadence, each scheduled run collects only the fresh window, which turns the Actor into a review monitoring feed: Glassdoor review monitoring.

Read Glassdoor from Claude over MCP

Through the Model Context Protocol, Claude, Claude Code, and Cursor can call the Actor as a tool and summarize live reviews mid-conversation. The config is in the task Pull Glassdoor reviews in Claude via MCP, and you can read more about Claude at claude.ai.

FAQ about scraping Glassdoor reviews

Is there an official Glassdoor API, or is a scraper the only way?

The old partner API is closed to new applicants, so for review data a scraper is the realistic option. This one behaves like the API you wish existed: documented input, structured output, predictable caps.

What does the Glassdoor reviews scraper cost?

Billing is per review returned, with no per-run setup fee, and the current per-review price is listed on the Actor's Store page. maxReviewsPerCompany caps volume and therefore cost before a run starts.

Is it legal to run a scraper on Glassdoor reviews?

The Actor collects only publicly visible review pages, nothing behind a login. Whether scraped review data fits your use case commercially is a question for your counsel and jurisdiction, and the honest answer is that norms differ.

Can Claude use the Glassdoor scraper through MCP?

Yes. Connect the Apify MCP server and the Actor shows up as a callable tool, so an agent can fetch reviews for a company and reason over the ratings in one exchange.

How do I schedule the scraper for continuous review monitoring?

Save a task with your company URLs, set days to match the cadence, and attach an Apify schedule. Each run appends the new window to your dataset. Start from the Glassdoor Reviews API.

Are the reviews the scraper returns reliable?

They are what Glassdoor shows: anonymous, self-selected, and skewed toward strong feelings, so treat single reviews as anecdotes and aggregates as the signal. Companies with few or no public reviews return few or no rows, and the scraper will not pad the difference.

More from Truffle Pig Data

Employer intelligence pairs well with two neighbors: the G2 Reviews API covers how a company's products are reviewed, and the LinkedIn Company API adds firmographics like size and industry for the same employers.

Wrapping up

Glassdoor never reopened its API, but the review data is still reachable as clean JSON. Point the Glassdoor Reviews API at a company page and see the breakdown for yourself.

Brave Search MCP Without an API Key: Get AI Mode Answers as JSON in 2026

Truffle Pig Data — Sun, 16 Aug 2026 19:47:27 +0000

AI answers are becoming the search result, and every engine writes its own. Brave Search is the interesting outlier: an independent index with a privacy-first audience, which means its AI Mode tells users a different story about your brand or topic than the mainstream engines do. I wanted that story as data, so I built the Brave AI Mode API on Apify. Give it a query and it returns the AI-generated answer, the sources it cites, and the supporting web results as one structured JSON record.

Disclosure: the Apify links in this post are affiliate links. If you run the Actor, I may earn a referral commission at no extra cost to you.

Doesn't Brave already sell a search API?

Yes, and credit where due: Brave's official Search API is one of the better ones an indie developer can get. But it's built around web results, it runs on API keys and plan quotas, and the AI Mode answer page, the thing users actually read, isn't what it hands you. If your question is "what does Brave's AI say about X, and who does it cite," you need the answer surface itself. This Actor scrapes exactly that and packages it like an API: query in, answer plus citations out, no Brave key to provision or babysit.

What the Brave AI Mode API returns

The Brave AI Mode API returns one record per query: the AI-generated answer text, the references it cites, and the supporting web results when present.

Field	Example	Notes
Query	`what is quantum computing`	The question you asked
AI answer	`Quantum computing uses...`	Full answer text as generated
Cited references	`[{title, url}, ...]`	The sources the answer leans on
Supporting web results	`[{title, url, snippet}, ...]`	The organic results beneath the answer
Country	`us`	Storefront of the search
Language	`en`	Interface language

One row holds the whole answer surface, which makes diffing runs over time straightforward.

Who this is for

Three audiences, in my experience. Marketing and SEO teams doing generative-engine monitoring, who need to know what AI answers claim about their brand and which domains get cited. Researchers and journalists who care specifically about the privacy-search ecosystem and its independent index. And agent builders who want an AI-grounded search tool without managing another vendor key.

The manual way, and where it breaks

You could check AI Mode by hand: type the query, read the answer, screenshot it, repeat next week. That survives about five keywords. Automating it yourself means a headless browser, because the answer streams in with JavaScript, plus session handling and markup that changes as Brave iterates on a young product. The iteration speed is the killer; new AI surfaces get redesigned monthly, and every redesign eats your selectors. I'd rather maintain that parser once, centrally, than have every reader maintain their own.

The faster way: run the Brave AI Mode API

Apify Console

Open the Brave AI Mode API and click Try for free.
Enter a query, or a queries list for batches, plus optional country and language.
Run it and download the answers as JSON or CSV.

REST

curl -X POST "https://api.apify.com/v2/acts/johnvc~brave-ai-mode-api/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "query": "what is quantum computing", "country": "us", "language": "en" }'

Run and dataset endpoints are described in the Apify API docs.

Pull AI answers in Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("johnvc/brave-ai-mode-api").call(
    run_input={
        "queries": [
            "best password manager",
            "is vpn worth it",
        ],
        "country": "us",
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item.get("query"))
    print(item.get("answer"))

AI Mode answers show up for informational, question-style searches, so phrase your queries the way a user asking a question would.

A Brave Search API alternative for AI answers

The task Brave Search API alternative: AI answers as JSON frames the core trade: no key signup, no plan tiers, just per-query billing for the answer surface.

Check many keywords in one run

Check Brave AI answers for many keywords uses the queries array for batch monitoring, the shape you want for a keyword portfolio.

Track your brand in AI answers

Track brand mentions in Brave AI search answers is the generative-engine-optimization play: run your brand queries on a schedule and watch how the answer's framing shifts.

See who gets cited

Track sources cited in Brave AI answers inverts the question: which domains does Brave's AI trust for your topic, and is yours among them? Citation share is the new ranking, and this is how you measure it on Brave.

Spreadsheet route

Export Brave AI answers to CSV runs entirely in the Console for the no-code crowd.

Brave Search MCP, without an API key

This is the setup I use most. Registered through Apify's MCP server, the Actor becomes a tool that Claude, Claude Code, and Cursor can call, so your agent can consult Brave's AI Mode mid-conversation with no Brave key involved. The task Brave Search AI for Claude via MCP, no API key walks through the config, and there's more on Claude itself at claude.ai.

FAQ about the Brave AI Mode scraper

What does the Brave AI scraper cost per query?

A cent and a half per query resolved, covering the answer, its citations, and the supporting results in one record. There's no subscription, and the free credit on a new Apify account funds a decent first monitoring batch.

Why use this scraper instead of the official Brave Search API?

Different artifact. The official API serves web results under key-and-quota plans; this scraper captures the AI Mode answer surface, citations included, which is the thing GEO monitoring actually measures. Plenty of projects sensibly use both.

Can Claude Code call the Brave scraper as a tool?

Yes. Over MCP it works from Claude, Claude Code, and Cursor alike, and the no-API-key task above is the fastest path to a working setup.

How do I schedule this scraper for weekly answer tracking?

Save your keyword batch as a task, attach an Apify schedule, and each run appends a dated snapshot you can diff for changed answers or lost citations. Start from the Brave AI Mode API.

What are the limits of an AI answer scraper?

AI Mode doesn't fire on every query; navigational and transactional searches often return no answer, and that's data too. Answers are also generated fresh, so expect wording variation between runs even when the substance holds. Track claims and citations rather than exact strings.

More from Truffle Pig Data

The same monitoring pattern works on other engines' AI surfaces: the Google AI Overview API for Google's answer box, the Bing Copilot API for Microsoft's, and the Naver AI Overview API for Korea's leading engine.

Wrapping up

What Brave's AI says about your topic is already influencing users; the only question is whether you're reading it as data. The Brave AI Mode API makes that a one-query experiment.

API Discovery in 2026: Scrape the RapidAPI Marketplace into One Sortable Dataset

Truffle Pig Data — Sun, 16 Aug 2026 08:10:25 +0000

Picking an API off RapidAPI Hub usually means thirty open tabs and a homemade spreadsheet: pricing on one tab, latency stats on another, ratings on a third, and no way to sort any of it. The catalog is public, but there is no export. This post shows how I turn that whole marketplace into structured data with the RapidAPI Marketplace API on Apify, one JSON row per listing.

Disclosure: the Apify links in this post are affiliate links. If you run the Actor, I may earn a referral commission at no extra cost to you.

Does RapidAPI have an API for its own catalog?

Here is the small irony: the biggest API marketplace does not offer a public API for searching its own listings. You can subscribe to any API on the hub, but there is no documented endpoint that returns "every weather API with its pricing model, popularity score, and latency" as data. For api discovery at any real scale, that leaves scraping the public catalog, which is exactly what this Actor packages: a search box you call programmatically, no RapidAPI account or key required.

What the RapidAPI Marketplace API returns

The RapidAPI Marketplace API returns public API listings as flat JSON records with pricing model, category, popularity, reliability metrics, publisher, and, in detailed mode, billing plans and ratings.

Field	Example	Notes
`title`	`Open Weather Map`	With `name`, `description`, and the listing `url`
`pricing`	`FREEMIUM`	FREE, FREEMIUM, or PAID
`popularityScore`	`9.8`	RapidAPI's 0 to 10 score
`avgLatency`	`142`	Milliseconds, with `avgSuccessRate` alongside
`billingPlans`	`{ "name": "Pro", "price": 10, "quota": "600 requests/minute" }`	Detailed mode
`subscriptionsCount`	`84213`	Detailed mode, with `ratingScore` and `ratingVotes`

Basic search rows carry the core fields; flip detailedInfo to true and each listing adds billing plans, subscriber counts, ratings, and the publisher's readme.

Who this is for

Developers doing api discovery who want to shortlist candidates on data instead of marketing pages. Product and research folks sizing a category, say, how many paid sentiment-analysis APIs exist and what they charge. And API publishers watching their own niche: who entered, what they price, how their popularity moves.

The manual way, and where it breaks

The DIY approach is to browse the hub and copy listings into a sheet, or script against the site directly. Copying breaks at about the tenth listing, when you realize the billing plans live two clicks deep on every page. Scripting breaks differently: the catalog renders through JavaScript, pagination is stateful, and the markup is not something anyone promises to keep stable. I built the tab-and-spreadsheet version myself before this Actor existed, which is a big part of why this Actor exists.

The faster way: run the RapidAPI scraper

Apify Console

Open the RapidAPI Marketplace API and click Try for free.
Add one or more searchTerms, set maxResults, and optionally enable detailedInfo.
Run it and export the dataset as JSON, CSV, or Excel.

REST

curl -X POST "https://api.apify.com/v2/acts/johnvc~rapidapi-marketplace-api/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "searchTerms": ["weather"], "maxResults": 25, "detailedInfo": true }'

Endpoint reference: the Apify API docs.

Shortlist APIs in Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("johnvc/rapidapi-marketplace-api").call(
    run_input={"searchTerms": ["weather"], "maxResults": 25}
)

for api in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(api["title"], api.get("pricing"), api.get("popularityScore"), api.get("avgLatency"))

Sort by popularityScore and you have a defensible shortlist in one run.

Compare every API in a category

The Actor ships with dozens of ready-made comparison tasks, one per category, so you can start from a preconfigured run instead of a blank input. Compare crypto APIs, compare news APIs, and compare LinkedIn APIs each pull a full category with pricing and reliability side by side.

Rank listings by rating, price, or popularity

Because every row carries scores and plans, sorting is a one-liner. The tasks find OCR APIs by rating, find PDF APIs by price, and find the most popular APIs by popularity score show the pattern.

Scan a niche in one run

Niche scans work the same way for any keyword: AI APIs, weather APIs, free APIs, and web scraping APIs by popularity are all one-click starts, and the Actor's examples tab lists the rest.

Let Claude do the API shopping over MCP

Connected through the Model Context Protocol, the Actor becomes a tool that Claude, Claude Code, or Cursor can call, so "find me a freemium geocoding API with good reliability" turns into a live catalog query with real numbers behind the answer. You can read more about Claude at claude.ai.

FAQ about scraping RapidAPI

How much does the RapidAPI scraper cost to run?

It is priced as a loss leader: 0.0001 dollars per listing returned, basic or detailed, with no start fee. A 500-listing category scan costs five cents, and you only pay for rows actually delivered.

Is it legal to run a scraper against RapidAPI listings?

The Actor collects only public marketplace listings, the same information any visitor sees, with no login and no paywalled content. As with any scraped source, check your own use case and jurisdiction before building on it commercially.

Can an AI agent use this scraper through MCP?

Yes. Expose it through the Apify MCP server and any MCP client, Claude included, can search the catalog as a tool call and reason over pricing and reliability fields in the response.

Can I schedule the scraper to track a niche over time?

You can, and it is the best way to catch new entrants and price changes. Save a task for your category, attach an Apify schedule, and diff the runs. Start from the RapidAPI Marketplace API.

What will this scraper not give me?

Anything behind a login or a subscription: no private APIs, no per-endpoint request consoles, no usage data beyond what listings publish. The readme field also only arrives in detailed mode, so basic rows stay lean by design.

More from Truffle Pig Data

Marketplace intelligence generalizes. The Apify Store API does the same job for Apify's Actor catalog, Apple App Store Search covers app marketplaces, and the G2 Reviews API adds review data for the vendors you find.

Wrapping up

API discovery should be a query, not an afternoon of tabs. Point the RapidAPI Marketplace API at your category and get the whole field as one sortable dataset.

Yelp Business API: How to Get Full Business Profiles as JSON in 2026

Truffle Pig Data — Sat, 15 Aug 2026 19:09:05 +0000

A Yelp business page holds more structured detail than almost any other local source: hours, amenities, price tier, popular dishes, review highlights, sometimes a full menu. Getting that detail out programmatically is the annoying part, since the official developer offering trims most of it away. Here is the manual route, its limits, and the shortcut: the Yelp Business API on Apify, which takes a place ID and returns the full profile as JSON.

Disclosure: the Apify links in this post are affiliate links. If you run the Actor, I may earn a referral commission at no extra cost to you.

Does Yelp have an API?

It does: Yelp Fusion, and for a search box in an app it is a fine choice. For data work it gets cramped fast. You need an API key, daily call limits apply, and the responses are slimmed down compared with what the public business page shows. Full menus, amenity lists, popular dishes, and review highlights are the kind of page-level detail the official response does not carry. A scraper-as-API closes that gap: the same public page, returned whole, as one JSON item per business.

What the Yelp Business API returns

The Yelp Business API returns a complete business profile per place ID: name, rating, review count, price, contact details, hours, amenities, and popular dishes as structured JSON.

Field	Example	Notes
`place_results.name`	`Maman`	With `categories` and `neighborhoods`
`rating`	`3.9`	Plus `reviews` count, here `847`
`price`	`$$`	Yelp's price tier
`operation_hours`	`{ "day": "Mon", "hours": "7:30 AM - 6:00 PM" }`	Per weekday
`features`	`{ "title": "Offers Delivery", "is_active": true }`	Amenities as structured flags
`popular_items`	`{ "title": "Almond Croissant", "reviews": 28 }`	Dishes with mention counts

Set full_menu to true and menu sections arrive in full_menu_results when the business publishes one on Yelp.

Who this is for

Teams building competitor profiles who want ratings and amenities across every rival in a neighborhood. Data folks enriching a lead list, turning bare business names into records with phone, website, and hours. And restaurant-tech builders who need menus and popular dishes as data rather than screenshots.

The manual way, and where it breaks

By hand, you open each business page and copy fields into a sheet, which holds up for about ten businesses and then collapses. Scripting it directly is harder than it looks: the page is JavaScript-heavy, anti-bot measures are real, and the interesting details sit in different page fragments that load separately. Keeping selectors alive across Yelp's layout updates becomes a part-time job. I would rather not have that job, which is roughly the origin story of this Actor.

The faster way: run the Yelp business scraper

Apify Console

Open the Yelp Business API and click Try for free.
Paste one or more place_ids, the slug from any Yelp business URL, like maman-new-york-22.
Run it and export the dataset as JSON, CSV, or Excel.

REST

curl -X POST "https://api.apify.com/v2/acts/johnvc~Yelp-Place-API/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "place_ids": ["maman-new-york-22"], "full_menu": false }'

The run lifecycle is in the Apify API docs.

Profile businesses in Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("johnvc/Yelp-Place-API").call(
    run_input={"place_ids": ["maman-new-york-22"]}
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    place = item.get("place_results", {})
    print(place.get("name"), place.get("rating"), place.get("reviews"), place.get("price"))

One item per place ID, so batching fifty competitors is just a longer list.

Get one business profile by ID

The minimal case, one ID in and one full profile out, lives in the task Get a Yelp business profile by ID.

Enrich a list of businesses in bulk

Feed a whole column of place IDs and get back a dataset with phone, website, hours, and ratings per row: Enrich Yelp business listings in bulk.

Extract a restaurant's full menu

With full_menu enabled, menu sections and items come back as data. The task Extract a restaurant's full menu from Yelp shows the exact input.

Check a health inspection score

Where Yelp displays a health inspection result for a business, the profile carries it, and the task Get a Yelp health inspection score by place ID pulls that signal on demand.

Track competitor ratings and amenities

Run the same ID list on a schedule and diff the output over time, which is the whole competitor-profiles recipe: Track Yelp competitor ratings and amenities.

Wire it into Claude over MCP

Through the Apify MCP server, the Actor becomes a tool that Claude, Claude Code, and Cursor can call directly, so "pull the profile for maman-new-york-22 and summarize the amenities" runs a live fetch instead of relying on memory. More on Claude at claude.ai.

FAQ about scraping Yelp business data

What does the Yelp business scraper cost per profile?

Pricing is per event: $0.02 to start a run and $0.02 per place processed. One business is about $0.04, ten in a batch about $0.22, and new Apify accounts include free platform credit to start.

Where does the scraper get its place IDs?

From any Yelp business URL: the slug after /biz/ is the ID. For discovery at scale, a companion search Actor returns IDs by term and location, which you then feed into this one.

Can the scraper return business hours and amenities?

Yes, both. Hours arrive per weekday in operation_hours, and amenities come back as structured features flags like "Offers Delivery" with an active state, which makes filtering trivial.

Can Claude call this Yelp scraper through MCP?

It can. Connect the Apify MCP server and the Actor appears as a callable tool in Claude, Claude Code, Cursor, and other MCP clients, with results returned into the conversation.

How do I schedule the scraper to watch competitors?

Save your ID list as a task, attach an Apify schedule, and each run appends timestamped profiles you can diff for rating and amenity changes. Start from the Yelp Business API.

What will the scraper miss?

Anything the public page does not show. Menus only come back when a business publishes one on Yelp, some profiles lack phones or websites, and a requested menu that does not exist returns a profile with menu_returned set to false rather than invented data.

More from Truffle Pig Data

This Actor is the middle of a three-stage suite: the Yelp Search API finds place IDs by term and location, this one profiles them, and the Yelp Reviews API pulls the full review text. For a second opinion on the same businesses, cross-reference with the Google Maps Places API.

Wrapping up

Yelp's business pages are dense with data that the official API never hands over. Feed a place ID to the Yelp Business API and get the whole profile back as JSON.