Yelp Scraper: Public Yelp Pages via API
ProxyField's 412M+ residential IPs run your own Yelp scraper today: rotating US IPs by state and city, from the Easy Trial (1 GB for $2.95). ProxyField's Web Scraping API is designed to fetch public Yelp search and business pages for $0.50 per 1,000 successful results over plain HTTP, $0.20 from 10,000 results in one purchase, or $2.00 per 1,000 with JS rendering, from $1.00; it is in development, so contact sales for access.
Through the sales team on our 24/7 live chat
| Fetch | Entry | Volume, from |
|---|---|---|
| HTTP | $0.50 | $0.20 |
| JS rendering | $2.00 | $1.00 |
Billed on successful results only.
Does the Yelp API return all of a business's reviews?
No. Yelp's Places API (formerly Fusion) "returns up to three review excerpts for a given business", of about 160 characters each, and "does not return full review text". The reviews endpoint needs the Enhanced or Premium plan; Yelp's plans page lists up to 3 excerpts per business on Enhanced, up to 7 on Premium and none on Base (Reviews API, Places API FAQ). Full text comes only through Yelp's Insights program: its Private Reviews endpoint gives "full-text reviews (most recent 200)" under a partnership agreement with Yelp (Yelp Insights). Anything beyond that is on the public pages, about ten recommended reviews per page.
Read moreShow less
| Route | What you get | Access and limits (Yelp's docs) |
|---|---|---|
| Yelp Places API | business search (up to 240 results per search) and details; review excerpts of about 160 characters: up to 3 on Enhanced, up to 7 on Premium, none on Base | API key; trial 5,000 calls in 30 days "for evaluation"; paid plans 30,000 calls a month, up to 5,000 a day; cache for 24 hours at most; "Analysis is not permitted" |
| Yelp Insights (Private Reviews) | full text of the most recent 200 reviews, review IDs, star ratings | by partnership agreement with your Yelp account team |
| Yelp Open Dataset | about 6.99 million reviews and 150,346 businesses in 11 metropolitan areas | a download "intended for educational use"; not current, not every city (Yelp Open Dataset) |
| Public pages: your own scraper, or the Web Scraping API | what the API does not give: every recommended review a logged-out visitor sees, about 10 per page with rating, date and full text, so about 20 requests for a 200-review business | Yelp's terms prohibit automated access without its permission (see the rules); the Web Scraping API is in development |
Reviews Yelp does not recommend sit on a separate page, outside the default review list. Scrape or API? If the excerpts are enough, use the Places API; if you need full text, Insights is the route inside Yelp's terms.
What ProxyField returns: the page itself, as HTML, Markdown, plain text or a JSON envelope. There are no pre-parsed Yelp fields, so your parser (or the Python below) turns pages into rows.
Scrape every review page of one business with Python
Decide first: need only a few excerpts, use the API snippet below. Need every recommended review, about 10 per page and about 20 requests for a 200-review business, then only with Yelp's permission or inside its terms: Yelp's support center says Yelp "does not allow any scraping".
The supported route comes first: Yelp's reviews endpoint, with an Enhanced or Premium API key, returns only up to 3 excerpts of about 160 characters (up to 7 on Premium) for one business:
import requests
resp = requests.get("https://api.yelp.com/v3/businesses/BUSINESS-ID-OR-ALIAS/reviews",
headers={"Authorization": "Bearer <yelp_api_key>"}, timeout=30)
resp.raise_for_status()
for r in resp.json()["reviews"]: # up to 3 excerpts (up to 7 on Premium)
print(r["rating"], r["time_created"], r["text"], r["url"])Read moreShow less
Before you run the loop below: Yelp's Terms of Service (section 7.2.10) prohibit robots, spiders and scrapers that access or copy Yelp content "except as expressly permitted by Yelp", and Yelp's support center says Yelp "does not allow any scraping", browser plug-ins and extensions included. ProxyField's rule for every site is public pages only, and follow the site's terms.
For more than the excerpts, the loop below walks ?start=0, ?start=10, ?start=20 … on one /biz/ page through rotating US residential IPs, keeps rating, date and text, stops when a page brings no new reviews, and writes a CSV.
-
Set the proxy with your login:
<login>-country-usgives a new US IP on every request (add-region-<region>-city-<city>for a city). -
Verify the first page before the loop, because the parser reads Review objects from the page's JSON-LD:
bash curl -s -x gate.proxyfield.io:7000 -U "<login>-country-us:<password>" \ -A "reviews-research/1.0 (+mailto:[email protected])" \ "https://www.yelp.com/biz/BUSINESS-SLUG" -o biz.html grep -c 'application/ld+json' biz.html # 1 or more: the page has JSON-LD grep -o '"@type": *"Review"' biz.html | wc -l # about 10: the reviews are in itA 0 on the second line means the reviews are not in the JSON-LD (read them from the HTML inparse_reviews) or the page is a challenge: openbiz.htmland look. -
Run the loop with the business's Yelp URL. Expect about 10 reviews per page (check the first page's count): a business with 200 reviews takes about 20 requests.
-
Watch the log each line prints the offset and the new reviews; a non-200 status stops the run and prints it. If the first page parses to 0 reviews, the loop prints the status and the first 200 characters of the page and stops: the page is a challenge, or its markup has no Review objects and
parse_reviewsneeds the HTML route. -
Stop condition a page with no review you have not seen means you are past the last page.
-
Check
reviews.csvone row per review (rating,date,text). Reviewer names are left out on purpose.
import csv, json, time
import requests
from bs4 import BeautifulSoup
PROXY = "http://<login>-country-us:<password>@gate.proxyfield.io:7000"
BIZ = "https://www.yelp.com/biz/BUSINESS-SLUG"
HEADERS = {"User-Agent": "reviews-research/1.0 (+mailto:[email protected])", # say who you are
"Accept-Language": "en-US,en;q=0.9"}
def parse_reviews(html):
"""Reviews from the page's schema.org JSON-LD (Review objects).
Check the page source first: if it carries no Review objects, read the
review blocks from the HTML here instead; the loop stays the same."""
rows = []
soup = BeautifulSoup(html, "html.parser")
for tag in soup.select('script[type="application/ld+json"]'):
try:
data = json.loads(tag.string or "{}")
except json.JSONDecodeError:
continue
for item in data if isinstance(data, list) else [data]:
if not isinstance(item, dict):
continue
for r in item.get("review", []):
rows.append({"rating": (r.get("reviewRating") or {}).get("ratingValue"),
"date": r.get("datePublished"),
"text": (r.get("description") or "").strip()})
return rows
seen, out, start = set(), [], 0
while True:
resp = requests.get(BIZ, params={"start": start}, headers=HEADERS,
proxies={"http": PROXY, "https": PROXY}, timeout=30)
if resp.status_code != 200:
print(f"stopped at start={start}: status {resp.status_code}")
break
rows = parse_reviews(resp.text)
if start == 0 and not rows: # nothing parsed on the first page: show what came back
print(f"0 reviews parsed at start=0 (status {resp.status_code}): {resp.text[:200]!r}")
break
new = [r for r in rows if (r["date"], r["text"][:80]) not in seen]
if not new: # nothing new: past the last review page
break
seen.update((r["date"], r["text"][:80]) for r in new)
out.extend(new)
print(f"start={start}: {len(new)} new, {len(out)} in total")
start += 10
time.sleep(5) # a few seconds between pages
with open("reviews.csv", "w", newline="", encoding="utf-8") as f:
writer = csv.DictWriter(f, fieldnames=["rating", "date", "text"])
writer.writeheader()
writer.writerows(out)A successful run on a business with 200 reviews prints:
start=0: 10 new, 10 in total
start=10: 10 new, 20 in total
…
start=190: 10 new, 200 in totalThe request at start=200 brings nothing new, the loop ends, and reviews.csv holds 200 rows.
What one business costs: 20 pages through the Web Scraping API is 20 results = $0.01 at $0.50 per 1,000. Through your own scraper it is traffic: at an example 1 MB a page, 20 pages are about 20 MB, or about $0.06 at $2.95/GB. Residential proxies cost $2.95/GB for 1 GB and from $1.95/GB at volume; the traffic never expires, and all purchases are final.
If a page needs a real browser, use Playwright or Puppeteer with the same gateway; more on proxies in Python in Python requests with a proxy. Username options after the location: -session-<id> and -ttl-<seconds> (30 to 129,600 seconds, 20 minutes by default), as in <login>-country-us-region-new_york-city-new_york-session-he9f2qga-ttl-600. Access opens once the payment is confirmed; the gateway, credentials or allowlist are in your account.
Every restaurant in a few US cities
The tools, by route:
- Inside Yelp's terms the Yelp Places API for business details (up to 240 results per search) and Yelp Insights for full review text, by partnership.
- No code a no-code tool such as Octoparse, or a ready-made Yelp scraper from a scraper marketplace.
- Your own job at scale Python on rotating US residential proxies today ($2.95/GB for 1 GB, $2.79/GB from 10 GB), or ProxyField's Web Scraping API once you have access ($0.50 per 1,000 successful results, $0.20 from 10,000; in development).
Read moreShow less
Before you buy any Yelp tool, check five things against this job (3 cities × 2,000 restaurants, 36,600 pages):
| Check | Why it matters here | What to look for |
|---|---|---|
| The 240-result cap | one search per city misses most restaurants | splits by ZIP code, neighbourhood or a map grid, and merges the results |
| Fields | you need one row per restaurant and per review | name, rating, review count, categories, price range, address, phone, hours; per review: rating, date, text |
| Price per 1,000 | the job is about 36,600 pages, or 6,000 businesses and their reviews | the tool's price per 1,000 businesses and per 1,000 reviews, times this job, against $7.32 to $18.30 (API, plain HTTP) or about $102 (residential proxies) |
| Free-plan caps | a free tier often stops below one city | the result cap per run and per month |
| Re-runs | restaurants open, close and get new reviews | a schedule, and a mode that fetches only new reviews |
Yelp's terms apply to every scraping route, bought or built.
Our recommendation: Yelp's Places API for business details inside Yelp's terms, Yelp Insights for full review text, and your own scraper on rotating US residential IPs, or the Web Scraping API once you have access, for public pages beyond that. Yelp's API returns up to 240 results per search (Places API FAQ), and the public search pages also stop after a limited number of pages. So one search per city does not list every restaurant: split each city into many smaller searches and merge them.
-
Split by place one search per neighbourhood or ZIP code in
find_loc(for examplefind_loc=78701), not one per city. -
Split by category one search per cuisine in
find_desc(pizza,thai,mexican…) inside each place. -
Page each search with
start=0, 10, 20 …until a page adds no new business. -
De-duplicate by the
/biz/<slug>URL the same restaurant shows up in neighbouring areas and several categories. -
Fetch each business page once for details (name, rating, review count, address, phone, hours), then its review pages if you need them.
-
Stop when searches stop adding restaurants
No single search shows every restaurant, so after each round of ZIP-by-cuisine searches, count the new
/biz/slugs it added. When a whole round adds under 2% new slugs (an example threshold), more searches will add little: report the slug count per city with the date.
What you end up with: one row per restaurant (Yelp URL, name, rating, review count, categories, price range, address, phone, hours) and one row per review (Yelp URL, rating, date, text), joined on the /biz/<slug> URL. Your parser builds them; the pages carry the fields.
What the job costs (example inputs: 3 cities × 2,000 restaurants; 600 search pages, 6,000 business pages and 5 review pages each = 30,000):
| Pages | HTTP $0.50 | HTTP $0.20 (from 10,000) | JS $2.00 | JS $1.00 | Your own scraper on residential proxies (works now) |
|---|---|---|---|---|---|
| 36,600 | $18.30 | $7.32 | $73.20 | $36.60 | about 36.6 GB at an example 1 MB a page: $102.11 at $2.79/GB |
The volume price applies from 10,000 successful results in one purchase. The API's design takes 20 concurrent requests per account and batches of up to 1,000 URLs, with a signed callback per finished job (API documentation).
What the job takes in time (arithmetic on the page count): one worker at one request every 5 seconds needs 36,600 × 5 s = about 51 hours. 20 workers at the same pace, the API design's 20 concurrent requests or 20 threads of your own scraper (threads on ProxyField are unlimited), need about 2.5 hours.
Yelp scraping tools compared
From the tools' own pages; prices and plans change, so check before you buy.
| Tool | Gives you | Fits | Limits |
|---|---|---|---|
| Yelp Places API | business search (up to 240 results per search), details, 3 review excerpts (7 on Premium) | business details inside Yelp's terms | 5,000 calls a day and 30,000 a month on paid plans; 24 h caching; no analysis |
| Yelp Insights or a data licence | full review text (the most recent 200), by agreement | commercial review analysis | partnership with Yelp |
| Yelp Open Dataset | about 6.99M reviews, 150,346 businesses, 11 metros | research and prototypes | educational use; not current, not your cities |
| Octoparse (no-code) | a scraping task built from a template, its AI assistant or Auto-detect in the desktop app; cloud runs with IP rotation | a one-off export without code | you set up the Yelp fields yourself; plans on its pricing page; Yelp's terms apply |
| Web Scraper (Chrome extension) | extraction defined visually in your browser; CSV and XLSX export, JSON on its Scale plan; cloud plans from $50 a month billed annually | a few hundred pages, visually | Yelp's support center names browser plug-ins and extensions in its no-scraping statement |
| Pre-built Yelp scrapers on scraper marketplaces | structured business and review rows as CSV or JSON, ready to run | a quick one-off export | Yelp's terms apply; each vendor's own per-result price: check the five points above (cap handling, fields, price for 36,600 pages, free-plan caps, re-runs) |
Python with requests and Beautiful Soup | the public pages you fetch | one business or a few hundred pages | you write and maintain the parser |
| Playwright | pages that need a browser | pages that load reviews with JavaScript | slower, more traffic per page |
| ProxyField residential proxies (works now) | rotating US IPs by state and city, 412M+ residential IPs in 195+ countries; one business's 20 review pages at an example 1 MB a page are about 20 MB, about $0.06 at $2.95/GB | your own scraper at any scale, today | Yelp's terms; your parser |
| ProxyField Web Scraping API (in development) | the page as HTML, Markdown, text or JSON, billed per successful result | city-wide jobs without running proxies | Contact sales; no parsed Yelp fields |
The Web Scraping API: how a request works
You send a Yelp URL, such as https://www.yelp.com/search?find_desc=dentists&find_loc=Austin%2C+TX&start=10, and the Web Scraping API returns the page, over plain HTTP or with JS rendering. The design takes a POST to https://api.proxyfield.io/v1/scrape with your API key in an Authorization: Bearer <api_key> header and a JSON body: url, render (false for plain HTTP, true for JS rendering), country and output (html, markdown, text or json). Parameter reference: API documentation.
# The request as designed (the API is in development; access through Contact sales)
curl https://api.proxyfield.io/v1/scrape \
-H "Authorization: Bearer <api_key>" \
-H "Content-Type: application/json" \
-d '{"url": "https://www.yelp.com/search?find_desc=dentists&find_loc=Austin%2C+TX&start=10", "render": false, "country": "us", "output": "json"}'The designed response (shortened; headers and cookies are the target's, content is the page's HTML):
{
"metadata": {"id": "req_e1378a7e8d527a0d", "api": "web_scrape", "status": "success", "billed": true},
"status_code": 200,
"final_url": "https://www.yelp.com/search?find_desc=dentists&find_loc=Austin%2C+TX&start=10",
"content_type": "text/html; charset=utf-8",
"headers": {"content-type": "text/html; charset=utf-8"},
"cookies": [],
"content": "<!DOCTYPE html><html lang=\"en-US\">…</html>"
}find_desc is what you look for, find_loc the city, neighbourhood or ZIP code, and start moves through the results ten at a time. On a business page, ?start=10 moves through the reviews the same way.
Pricing: $0.50 per 1,000 pages, from $0.20
Start with plain HTTP at $0.50 per 1,000 successful results, $0.20 from 10,000 in one purchase. If a page arrives without the listings or reviews, switch it to JS rendering: $2.00 per 1,000, from $1.00.
You pay only for successful results. Billed: a page Yelp served, including a 404 or 410 and a sign-in page served with a 200 status. Not billed: error responses, blocked and timed-out requests, and our internal retries. Every response says whether it was billed.
One result is one page; a business with 50 reviews is about five review pages. The API is paid from the same crypto balance as proxies, which never expires; there is no subscription or monthly fee. All prices: pricing. Sales contact: the sales team on our 24/7 live chat.
Through the sales team on our 24/7 live chat
| Workload (30-day month) | Pages a month | HTTP $0.50 | HTTP $0.20 | JS $2.00 | JS $1.00 |
|---|---|---|---|---|---|
| 20 cities × 10 categories, 2 search pages each, daily | 12,000 | $6 | $2.40 | $24 | $12 |
| 2,000 businesses, 5 review pages each, monthly | 10,000 | $5 | $2 | $20 | $10 |
| 10,000 business pages a day | 300,000 | $150 | $60 | $600 | $300 |
When Yelp refuses a request
Yelp is quick to refuse automated traffic: a fast run from one IP soon gets a captcha page, a 403 or a page without the data. With your own scraper, pace it: one request every few seconds, a new residential IP per request, the headers a browser sends, and a check of each page for the fields you expect before you store it. If Yelp keeps refusing, its API is the supported route.
What teams use Yelp data for
- Local market research: how many businesses of a type a city has, their ratings and price range.
- Review analysis: what customers praise and complain about in a category.
- Reputation monitoring of your own locations next to nearby competitors.
- Business directories and data checks: current addresses, phone numbers and hours.
Posting or editing reviews through a script is not data collection: fake accounts and fake engagement are forbidden under ProxyField's acceptable use policy.
Yelp's terms and the law
Yelp's Terms of Service (effective January 1, 2026), section 7.2.10, prohibit using "any robot, spider, Service search/retrieval application, or other automated device" to access, retrieve, copy, scrape or index Yelp content "except as expressly permitted by Yelp (for example, as described at www.yelp.com/robots.txt)", so permission means what Yelp's robots.txt allows or Yelp's own written permission; the Business Terms (section 1.2.6) say the same for business users. Reviews also carry reviewers' personal data, which EU and UK data protection law covers: collect only what your purpose needs. For the wider question, read Is Web Scraping Legal? US, EU and UK Rules (2026) and web scraping law in the UK and EU.
ProxyField's rule for every site: public pages only, and follow the site's terms.
This is not legal advice.
More scrapers
- Review scraper for review sites in general, and the travel review scraper for hotels, restaurants and attractions, on the same Web Scraping API.
- Google Maps scraper API: Google Maps search results.
- Lead scraper for business contact lists from public directories.
- Google SERP API: Google results with the local pack parsed, $1.20 per 1,000 successful results, from $0.80.
- All scrapers: scrapers.
Yelp Scraper FAQ
24/7 support by live chat, including help with setup and integration.
What are the best tools for scraping Yelp business details and reviews for every restaurant in a few US cities?
ProxyField recommends Yelp's Places API for business details and review excerpts inside Yelp's terms (up to 240 results per search, so split each city by ZIP code and cuisine), Yelp Insights for full review text, no-code tools such as Octoparse or a marketplace scraper for a one-off export, and your own Python scraper on residential proxies for the full job: about $102 for 3 cities × 2,000 restaurants (36,600 pages at an example 1 MB), about 2.5 hours with 20 workers. ProxyField's Web Scraping API, in development, prices the same 36,600 pages at $7.32 to $18.30 over plain HTTP. Whatever the tool, check that it handles the 240-result cap, de-duplicate restaurants by their /biz/<slug> URL, and stop adding searches when a round adds under 2% new restaurants.
Does the official Yelp API return all of a business's reviews, or do I have to scrape Yelp to get them?
No: the reviews endpoint returns up to three review excerpts per business, about 160 characters each, and Yelp's plans page lists up to 7 on Premium and none on Base. Full text of the most recent 200 reviews comes through Yelp Insights under a partnership agreement. The public pages show about ten recommended reviews per page, but Yelp's terms prohibit scraping them without its permission.
How do I scrape Yelp reviews with Python across every review page of a single business?
Yelp does not allow scraping (Terms, section 7.2.10), and the supported reviews endpoint returns up to three excerpts with a Bearer API key. The loop on this page requests the /biz/ page with ?start=0, ?start=10, ?start=20 and so on through a proxy, about 10 reviews per page, and stops when a page brings no new review: a business with 200 reviews is about 20 requests, 5 seconds apart. Check first that the page's JSON-LD carries about 10 Review objects (grep -o '"@type": *"Review"').
How much does it cost to scrape Yelp?
ProxyField's Web Scraping API is priced at $0.50 per 1,000 successful results over plain HTTP, $0.20 from 10,000, and $2.00 per 1,000 with JS rendering, from $1.00. Reading five review pages for each of 2,000 businesses is 10,000 pages: $5 over plain HTTP. Your own scraper on residential proxies starts at 1 GB for $2.95.
What is a Yelp scraper?
A tool or script that collects public Yelp data, such as business names, ratings, review counts, addresses, hours and review text, from search and business pages. It reads what a logged-out visitor sees, where Yelp's API returns a fixed set of fields to key holders.
How do I scrape Yelp data?
Build search URLs with find_desc and find_loc, collect the /biz/ links from each results page, then fetch every business page and parse its fields. Run the Python on this page through rotating residential proxies, or send the URLs to the Web Scraping API once you have access.
How do I scrape Yelp reviews?
Fetch the business page and page through its reviews with ?start=10, ?start=20 and so on, keeping the star rating, date and text of each. Yelp shows its recommended reviews by default; the ones it does not recommend sit on a separate page.
Is there an official Yelp API?
Yes: the Yelp Places API (formerly Fusion) returns business search (up to 240 results per search), business details and review excerpts as JSON. It has a 30-day trial of 5,000 calls for evaluation, and paid plans with 30,000 calls a month and up to 5,000 a day.
What data can I get from the Yelp API?
Business search results, business details such as name, rating, review count, categories, address, phone and hours, and review excerpts of about 160 characters (up to 3 on Enhanced, up to 7 on Premium). Yelp lets you cache the content for 24 hours at most and does not permit analysis on Places API data.
Does a Yelp scraper need a Yelp API key?
No: a scraper reads public pages with no Yelp key or Yelp login. The key belongs to Yelp's own API, which returns a fixed set of fields to key holders.
Show 12 more questionsShow fewer questions
What data can I get by scraping Yelp?
Search pages show business names, ratings, review counts, categories, price range and neighbourhood; business pages add address, phone, website, opening hours, amenities and recommended reviews. Anything behind a Yelp login is out of scope under ProxyField's acceptable use policy.
What does a Yelp reviews scraper collect?
For each review, the star rating, date, text and the business it belongs to, and sometimes owner replies and photos. Reviewer names and profile links are on the page too, but most analysis works without them.
How many Yelp reviews can I scrape per business?
All the recommended reviews the public page shows, about ten per page, so a business with 200 reviews is around 20 page fetches. Each page is one billed result on the Web Scraping API: $0.01 for 20 pages at $0.50 per 1,000.
Should I keep reviewer names when I scrape Yelp reviews?
Only if your purpose needs them. Names and profile links are personal data under EU and UK law, while rating, date and text are enough for most review analysis, so drop or pseudonymise the rest.
Do Yelp pages need JavaScript rendering?
Try plain HTTP first at $0.50 per 1,000 and check that the listings or reviews are in the page. If they are missing, fetch that page type with JS rendering at $2.00 per 1,000, from $1.00.
Is GraphQL better than BeautifulSoup for scraping Yelp?
Yelp's site calls internal GraphQL endpoints, which return clean JSON but are undocumented and can change without notice. Parsing the public page's HTML or JSON-LD with Beautiful Soup is slower to write but follows what visitors see; either way, Yelp's terms apply.
Does Yelp block scrapers?
Yes: fast or repetitive requests from one IP soon get a captcha page, a 403 or a page without the data. Keep a few seconds between requests, use a new residential IP per request, and check each page before you store it.
Does Yelp allow scraping?
No: section 7.2.10 of Yelp's Terms of Service prohibits robots, spiders and scrapers except as Yelp expressly permits. Use its API or a Yelp partnership where they fit, and check any scraping against the terms first.
Are there alternatives to scraping Yelp?
Yes: the Yelp Places API for business details, Yelp Insights for the most recent 200 full-text reviews by agreement, and the Yelp Open Dataset (about 6.99M reviews in 11 metros) for educational use. Business data from other sources, such as Google Maps listings, is another route.
Why do teams collect Yelp data?
For local market research, review and sentiment analysis, reputation monitoring of their own locations, and keeping business directories current. Yelp covers restaurants and local services in depth, especially in the US.
How do I scrape data from Yelp without code?
No-code tools such as Octoparse and browser extensions such as Web Scraper copy what a browser shows, which works for a few hundred pages; Yelp's support center names plug-ins and extensions in its no-scraping statement. For scheduled jobs, a no-code tool or workflow can call an API with Yelp URLs instead, such as ProxyField's Web Scraping API (in development) at $0.50 per 1,000 pages.
In what format do I get Yelp data?
The Web Scraping API returns the Yelp page, and your parser turns it into rows for CSV, a spreadsheet or a database. The page comes back as HTML, Markdown or plain text, or as a JSON envelope with the status code, the final URL, the content type, the target's headers and cookies, and the content, as in the sample response above; there are no pre-parsed Yelp fields.
Related pages
Collect Yelp pages with the Web Scraping API
Billed on successful results only. Contact sales for the Web Scraping API and the volume you need, or run your own scraper on residential proxies. 24/7 live chat helps with setup and integration.