Yelp API: Search Businesses and Pull Reviews for a City

Get Yelp businesses, ratings and reviews for a whole city in one prompt. Paste this into your agent:

Set up https://monid.ai/SKILL.md, and then use Monid to search Yelp for coffee shops in Austin, TX sorted by review count, keep the paid ads apart from the organic results, pull 49 reviews for each of the top ten, and tell me which ones reply to their reviews.

One prompt builds a local list. 1 min setup · 20-40 hrs saved.

You want a list of local businesses with their ratings, phone numbers and reviews: for a lead list, a competitor map, or a reputation check across many shops. This guide shows the quickest way to get Yelp results and reviews into your agent or spreadsheet, what each record contains (we ran it live on 2026-10-16), and the traps we hit: paid placements that arrive in their own array, a coffee search that returns a cocktail bar, and a rating filter that disappears when you page. It runs through Monid, the OpenRouter for agent tools: one key, one balance, every tool priced per call.

What is the easiest way to get Yelp business data through an API?

Monid. Install it once, add a key, and your agent calls Yelp search and Yelp reviews with no developer portal, no plan and no vendor account to set up.

• Pay per call. Each call is billed on its own, at $0.00015 for the Yelp search and the Yelp reviews endpoints (Verified 2026-10-16 on the local data tools page). Buy calls as you need them: no monthly plan and no minimum top-up. Only a run bills.
• One install, every API. The same key and the same balance call Yelp and every other tool on Monid. No new account for TripAdvisor, Google or Zillow when you need them next. Building and wiring those yourself is the 20 to 40 hours this page claims to save.
• Lives inside your agent. Install the CLI, add your key, run the prompt above, and the tools are there whenever your agent needs them, on demand, with nothing to keep running. Your agent reads SKILL.md and learns the rest, so setup is about a minute.

At that price a full sweep of a 240-result search is 24 calls, which is $0.0036 (Verified 2026-10-16).

How do you get Yelp businesses and reviews for a whole city?

Run one search per page, take the place_id off each row, and pass it to the reviews endpoint. Relying on one source per city is the trap why one Google Maps scraper is not enough describes. The search row already carries a ready-made reviews call, so there is no lookup step in between.

For agents

Grab an API key at app.monid.ai, then paste this to your agent and hand it the key:

set up https://monid.ai/SKILL.md

It learns the whole discover, inspect, run workflow itself. More in the agent quickstart.

For humans

npm install -g @monid-ai/cli
monid keys add -k <your-api-key> -l main

Step 1, search

monid run -p litescrape -e /yelp/search \
  --query '{"find_loc":"Austin, TX","find_desc":"coffee","sortby":"review_count"}'

find_loc is the only required field. find_desc takes a name or a search term, cflt takes a Yelp category identifier such as coffee if you would rather browse than search, sortby accepts recommended, rating or review_count, and attrs takes filters such as open_now.

Step 2, read the counts before you loop

const { total_results, results_per_page } = res.search_information;
const pages = Math.ceil(total_results / results_per_page);  // 24 for Austin coffee

Decide whether you want all 24 before you start.

Step 3, follow the supplied next call

The response hands you litescrape_pagination.next, a ready-made endpoint with its parameters and the next start offset already filled in. Send it rather than building your own offset.

Step 4, chain into reviews with the id you already have

monid run -p litescrape -e /yelp/reviews \
  --query '{"place_id":"-4ofMtrD7pSpZIX5pnDkig","num":49,"sortby":"relevance_desc"}'

Ask for 49 if you are going to analyse the text. A call costs the same whatever num is, and 49 is the maximum.

Step 5, loop it over your cities

Put one city per line in cities.txt, then run (the same sweep-by-city pattern is in automating Google Maps business listings):

mkdir -p out
while read -r city; do
  monid run -p litescrape -e /yelp/search \
    --query "{\"find_loc\":\"$city\",\"find_desc\":\"coffee\",\"sortby\":\"review_count\"}" > "out/$(echo "$city" | tr ' ,' '__').json"
done < cities.txt

Each city writes one file with its first page.

Or hand the whole job to an agent

Can you scrape Yelp yourself with Python?

Yes, people do it with Requests, BeautifulSoup, Selenium or Playwright, and it works until the page changes. A scraper you write is yours to keep alive: when the markup or the blocking changes, your job breaks, and your list is only as fresh as your last successful run.

Read the site's terms before you build anything: what you may do depends on where you operate and how you use the data.

Doing it in Python means a proxy or browser setup, parsing code, retries and paging logic, and repairs. A search page mixes paid placements with organic results, so your parser has to work out which is which. That takes hours before the first useful row. A call through Monid costs $0.00015 (Verified 2026-10-16). Set against hours of your own time, the choice is easy for anything you will run more than once: the collection is maintained for you, the ads are already separated, and the output is typed JSON instead of HTML you parse. If you want to see the DIY route first, Google Maps scraper alternatives compares the scraper routes for local data. A downloadable dataset suits a one-off look, but it is a snapshot of one date.

What does Yelp data look like, and what can you build with it?

Two kinds of record, chained by place_id: the search row and the reviews. We ran both on 2026-10-16 for coffee in Austin, so the fields below are what came back, not what a spec promises.

The search row

One call returned ten organic businesses, four ads, and search_information.total_results of 240 at 10 a page. An organic row, trimmed:

{ "position": 1,
  "place_id": "-4ofMtrD7pSpZIX5pnDkig",
  "title": "Mozart's Coffee Roasters",
  "categories": [ { "title": "Coffee & Tea Shops" }, { "title": "Coffee Roasteries" }, { "title": "Desserts" } ],
  "price": "$$",
  "rating": 4,
  "reviews": 2158,
  "address": "3825 Lake Austin Blvd", "city": "Austin", "state": "TX", "postal_code": "78703",
  "gps_coordinates": { "latitude": 30.29547, "longitude": -97.783951 },
  "phone": "(512) 477-2900",
  "highlights": [ "29 years in business", "Family-owned & operated" ],
  "snippet": "…",
  "reviews_link": { "endpoint": "/yelp/reviews", "queryParams": { "place_id": "-4ofMtrD7pSpZIX5pnDkig" } } }

That is a lead-list row with no second call: name, phone, address split into fields, coordinates, rating, review count, price band and categories. A filters block lists the category and attribute values Yelp offers for the search, which you can feed back in through cflt and attrs.

The ads

Paid placements come back in a separate ads_results array with a place_id and reviews_link, but a block_position of top or bottom instead of a rank, and no street address or coordinates on the four we got.

The reviews

The reviews endpoint returns the text, not just the score. Each review has a rating, comment.text and language, a date and local_date, the user (name, location, and counts of friends, photos and reviews), feedback and reactions counts, photos when the reviewer attached any, and owner_replies with the owner's name, role, text and date. The envelope adds the star distribution and the total. For Mozart's Coffee Roasters that was 2,153 English reviews: 132 one-star, 154 two-star, 239 three-star, 710 four-star and 923 five-star. You can order by relevance_desc, date_desc, date_asc, rating_desc, rating_asc or elites_desc, keep only chosen star ratings, pick a language with hl, and take 1 to 49 per call.

What you can build with it

• A local lead list. Name, phone, address, rating and review count for every business in a category and a city, sorted by the field you mean.
• A competitor map. Run the same search every month and compare ratings, review counts and who appears among the ads.
• A complaints digest. Filter to one and two stars, sorted by date, and read what customers are unhappy about this quarter. For the top Austin result that was 284 reviews, and the five newest all had a manager reply.

What goes wrong when you pull Yelp data at scale?

Four things hide until you run more than one city. All four showed up in our Austin run on 2026-10-16.

Why do the ads rank above better businesses?

They sit in their own array, and merged into your ranking they would beat every organic result. We asked for sortby: review_count, which the organic list honoured exactly:

organic  1  Mozart's Coffee Roasters   4.0   2,158 reviews
organic  2  Paperboy East              4.5   1,475
organic  3  Jo's Hot Coffee Good Food  4.0   1,004
         …
organic 10  Kick Butt Coffee           4.0     560

ads         Anderson's Coffee Company  4.6     199
ads         Black Rock Coffee Bar      4.4       5
ads         Starbucks                  3.9      80
ads         Capital One Café           4.4      75

The weakest ad has 5 reviews against the organic leader's 2,158. A coffee shop ends up below a bank's café lounge when a pipeline concatenates the two arrays:

// the bug
const all = [...res.ads_results, ...res.organic_results];

Now your top four coffee shops are four advertisers, and every downstream score inherits it. Split at the point you read the response and keep the ads in their own column. They are useful data about a different question: who is paying to reach customers in this category.

const businesses = res.organic_results;   // rank these
const advertisers = res.ads_results;      // keep, separately

Why did a coffee search return a cocktail bar?

Because Yelp matches on a business's category list, and businesses carry several categories. In our ten organic rows, rank 6 is tagged Tacos and Pizza next to coffee, rank 7 Bars and Food Trucks, rank 8 Cocktail Bars and Australian, and rank 10 Bars and Music Venues. A sort orders a set; it does not decide what belongs in it. Every row returns its categories, so check them against what you meant before the business reaches your list:

const coffee = rows.filter(r => r.categories.some(c => c.title === "Coffee & Tea Shops"));

Why does the rating filter vanish when you page?

We asked for one and two star reviews only, five per page. The first page was right: 284 matching reviews, the 132 one-star plus the 154 two-star. But the pagination.next it handed back carried place_id, sortby, start and num and no rating. Follow it as it is and page two is every star rating. When you filter by rating, copy the next call and add the rating array back yourself.

How many calls is a whole city?

24 for this one query, 240 results at 10 a page, and 44 more to read one business with 2,153 reviews in full at 49 a call. At $0.00015 a call (Verified 2026-10-16) that is $0.0036 for the listing sweep and $0.0066 for the full review history of one business. Ten cities is 240 calls for the listings alone. Narrow by neighborhood or category first, or take the first pages.

Which endpoint should I use for which job?

The two Yelp rows were inspected on 2026-10-16 and the latency is each endpoint's typical (median) run time; the other rows were last checked on 2026-10-02. Billing shape is given here, and the current figure is on monid.ai/tools.

The first two rows are one pipeline: search gives you the place_id and reviews takes it. For hotels and attractions, how TripAdvisor search works covers the travel side; the two sources answer different questions, and a place_id from one will not match the other, so keep them in separate columns.

When is another route a better fit?

You need the whole category in a city. Our search reported 240 results at 10 a page, so a full sweep is 24 calls before any reviews. That is fine for one market and heavier for fifty. Narrow by neighborhood or category first.

Yelp is not where your market lives. Coverage is strongest for restaurants, bars and consumer services. For B2B services, a reviews source built for that is a better starting point, and outside the US sample a few cities first.

You want one true rating. Ratings differ by platform because the reviewer populations differ. If the rating is going into a decision, read more than one source, so read two or three sources before you pick a winner.

You are republishing the review text. The ratings and counts are facts about a business. The reviews are writing by individual people. Analysing them to produce a summary is ordinary; reposting them as your own content is a different act, and the rules differ by country and platform, so check yours.

And the disclosure: we resell these endpoints. The most useful thing in this post costs nothing, which is to keep ads_results out of your ranking, and that applies whichever source you buy from.

Conclusion

The quickest way to get Yelp businesses and reviews for a whole city is one search call per page through Monid: $0.00015 a call (Verified 2026-10-16), one key for Yelp and everything else, about a minute to set up and ready inside your agent whenever you need it. A 240-result search is 24 calls, $0.0036. Scraping it yourself works until the page changes, and costs hours of setup; Monid keeps the collection maintained.

Two things matter more than the choice of tool. The ads arrive in their own array, and the only way to waste that is a spread operator that merges them into the ranking: our weakest ad had 5 reviews against the organic leader's 2,158. And a category search returns anything whose category list overlaps, so filter on categories after the fetch. Also read owner_replies: 41 of the 49 relevance-sorted reviews we pulled for the top Austin result had a reply.

How we estimated the time saved: building and running your own Yelp scraper is roughly 10 to 20 hours each for the search side and the reviews side, covering blocking, parsing, paging, separating ads and the first month of upkeep. That is 20 to 40 hours. The 1 minute is the install, key and first call once you already have a Monid key.

Free next step: run monid inspect -p litescrape -e /yelp/search, make one call, and print organic_results.length next to ads_results.length. Start at monid.ai.

FAQ

Published October 2026.