Web Scraping API: Any URL, With or Without JavaScript Rendering
ProxyField's Web Scraping API fetches any public URL and returns the page, for $0.50 per 1,000 successful results over plain HTTP (from $0.20 at volume) or $2.00 per 1,000 with JavaScript rendering (from $1.00), which is $0.002 a rendered page. You pay only for successful results; to start, contact sales. There is no free tier, but a small project costs little: 10,000 plain-HTTP results cost $5.00 and 1,000 rendered results cost $2.00.
Prefer your own scraper? Residential proxies from $1.95/GB
| Rate | Entry | Volume, from |
|---|---|---|
| HTTP | $0.50 | $0.20 |
| JS rendering | $2.00 | $1.00 |
Billed on successful results only.
For JavaScript-heavy pages, such as React, Vue or Angular apps or prices that load after the page, switch rendering on per request: $2.00 per 1,000 successful results, from $1.00, while plain HTTP pages stay at $0.50. Send a URL, choose plain HTTP or JavaScript rendering, and get the page back as HTML, Markdown, plain text, a JSON envelope or, with rendering, a screenshot. The fetch runs on ProxyField's side; you send URLs and parse what comes back.
Web scraping API for JavaScript-heavy sites
For a JavaScript-heavy site, use an API that renders per request and bills only successful results: ProxyField's Web Scraping API renders for $2.00 per 1,000 successful results (from $1.00), which is $0.002 a page, and fetches the pages that don't need it over plain HTTP for $0.50. Rendering runs the page's scripts before the page is returned, so content that single-page apps and scripts add is in the result.
Read moreShow less
| What you see | Why | Mode | Per 1,000 successful results |
|---|---|---|---|
| The data is in the page source (Ctrl+U) | the server sends finished HTML | plain HTTP | $0.50, from $0.20 |
The source holds an empty shell such as <div id="root"></div> | a script framework (React, Vue, Angular) builds the page | JavaScript rendering | $2.00, from $1.00 |
| Prices or stock appear a moment after the page loads | a script fetches them from the site's own API | rendering, or that API's URL over plain HTTP | $2.00, or $0.50 |
| More items load as you scroll | the page requests the next items by script | the URL the page calls for the next items, over plain HTTP | $0.50 |
Test each target before you choose: fetch it over plain HTTP and look for a field you need.
curl -s "https://example.com/item/42" | grep -c "a value you can see on the page"0 means the value is built by a script, so use rendering or the page's own data request; 1 or more means plain HTTP is enough. More ways to tell: scraping dynamic web pages.
What it costs at the entry prices: 10,000 rendered pages cost $20.00 and 100,000 cost $200.00; the same pages over plain HTTP cost $5.00 and $50.00. Rendering settings: wait adds a pause after the page loads (up to 35,000 ms), wait_for waits until a CSS selector or an XPath appears, wait_until picks the page event that counts as loaded (domcontentloaded, load or networkidle), and actions runs up to 20 browser steps in order: click, fill a field, scroll, wait, wait for an element, run JavaScript and infinite scroll. All of them work on rendered requests only.
What to compare in a JavaScript rendering API
| Check | Why it matters on JavaScript-heavy sites | ProxyField Web Scraping API |
|---|---|---|
| Rendering per request, or always on | you pay the rendering price only on pages that need it | per request |
| Billing unit | credit plans charge several credits for a rendered page, so the real price is hidden in a multiplier | US dollars per 1,000 successful results |
| Failed or blocked pages | a render that fails should not cost you | billed on successful results only |
| Price per 1,000 rendered pages | the number to compare across APIs | $2.00, from $1.00 at volume |
| Price per 1,000 plain pages | most sites mix both kinds of page | $0.50, from $0.20 at volume |
| Wait time, wait for a selector, scroll and click | content that loads late, infinite scroll, "load more" buttons | wait, wait_for, wait_until and up to 20 browser actions per request |
| Output | HTML for your parser, or parsed fields | HTML, Markdown, plain text, a JSON envelope or a screenshot; no parsed fields |
JavaScript-heavy checklist
-
Look at the source (Ctrl+U) or run the
curl | grep -ctest above. The value is there: plain HTTP, $0.50 per 1,000. An empty<div id="root"></div>: rendering, $2.00 per 1,000. -
Look for the page's own data request
In the browser's developer tools, Network tab, filter by Fetch/XHR and reload: a JSON response with your prices or items can be fetched over plain HTTP at $0.50 instead of rendering the page.
-
Render only the URLs that need it
Rendering is a switch on each request, not a plan.
-
Budget in dollars rendered pages × $0.002. 10,000 rendered pages = $20.00; 100,000 = $200.00.
-
Count only successes you are billed on successful results only, so a render that fails is not billed.
Hobby and small projects
No free tier, but 1,000 plain pages cost $0.50 and 1,000 rendered pages $2.00, billed on successful results only; 10,000 plain pages cost $5.00. A first test of 100 pages costs $0.05 over plain HTTP, or $0.20 rendered.
| Pages | Plain HTTP | With JavaScript rendering |
|---|---|---|
| 100 (a first test) | $0.05 | $0.20 |
| 1,000 | $0.50 | $2.00 |
| 5,000 | $2.50 | $10.00 |
| 10,000 | $5.00 | $20.00 |
The APIs are paid from the shared balance, topped up from $2.95; there is no separate test volume. Start on one target with 100 pages and compare the result with your own script.
To pay nothing for software, run an open-source library on your own machine (more options in free web scraping tools). Requests with Beautiful Soup, for pages whose data is in the HTML (Beautiful Soup guide):
# pip install requests beautifulsoup4
import requests
from bs4 import BeautifulSoup
html = requests.get("https://example.com/", headers={"User-Agent": "Mozilla/5.0"}, timeout=30).text
soup = BeautifulSoup(html, "html.parser")
print(soup.title.string, [a["href"] for a in soup.select("a[href]")][:5])Playwright, for pages built by scripts (Playwright guide):
# pip install playwright && playwright install chromium
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch()
page = browser.new_page()
page.goto("https://example.com/", wait_until="networkidle")
print(page.content()[:500])
browser.close()If the site starts to limit you, add a proxy: proxies={"https": "http://<login>:<password>@gate.proxyfield.io:7000"} in Requests, or p.chromium.launch(proxy={"server": "http://gate.proxyfield.io:7000", "username": "<login>", "password": "<password>"}) in Playwright, from the Easy Trial: 1 GB for $2.95.
What the Web Scraping API does
You send a URL; the API fetches the page, over plain HTTP or with JavaScript rendering if you ask for it, and returns the content to you. You pay only for successful results.
-
Send the URL and say whether the page needs JavaScript rendering.
-
The API fetches the page
Plain HTTP for pages whose content is in the HTML; a rendered page for content that loads in the browser.
-
You get the page back and parse the fields you need. You are billed on successful results only.
It works as a data scraper for product pages, articles, listings, directories and metadata, and as a URL scraper for a list of addresses you already have. One API covers any public site; for the sites that have their own ProxyField API, use that API instead (see All scraper APIs).
Request and response
A request carries the URL and the choice of plain HTTP or JavaScript rendering; the response carries the page. The API 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. Parameter reference: API documentation.
Read moreShow less
| Parameter | What it sets |
|---|---|
url | The page to fetch |
render | false (the default): plain HTTP at the HTTP price; true: the page is loaded in a browser, at the JS price |
country | The country of the exit IP, as a two-letter code such as gb |
session_id | Requests with the same id leave from the same IP |
method, body, headers, cookies | Sent to the site as you give them: GET, POST or PUT, a request body, your headers and cookies |
device | desktop or mobile |
wait, wait_for, wait_until, actions | The rendering settings above (rendered requests only) |
output | html (the default), markdown, text, json or screenshot (a PNG, with rendering) |
tag | Your own label, returned with the result |
# The request the Web Scraping API takes (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.example-shop.com/category/grinders?page=2", "render": true, "wait_for": ".product-card",
"actions": [{"type": "click", "selector": "#accept-cookies"}, {"type": "scroll", "to": "bottom"}],
"country": "gb", "output": "json"}'With output set to html, markdown or text, the response is the page itself, and the site's status code and final URL come in the X-Target-Status and X-Final-Url headers. With json, the page comes in an envelope with the site's status code, the final URL, the content type, the site's headers and cookies, the content and a log of the browser actions. Example response (shortened):
{
"metadata": {"id": "req_41ac7e93d05f2b68", "api": "web_scrape", "status": "success", "billed": true},
"status_code": 200,
"final_url": "https://www.example-shop.com/category/grinders?page=2",
"content_type": "text/html; charset=utf-8",
"cookies": [{"name": "consent", "value": "accepted", "domain": ".example-shop.com", "path": "/"}],
"content": "<!DOCTYPE html><html lang=\"en-GB\"><head><title>Grinders - page 2</title></head><body>…</body></html>",
"actions_log": [{"type": "click", "ok": true}, {"type": "scroll", "ok": true}]
}Every response says whether it was billed, in the X-Billed header and in metadata.billed.
Web Scraping API pricing
The Web Scraping API costs $0.50 per 1,000 successful results over plain HTTP, from $0.20 at volume, and $2.00 per 1,000 with JavaScript rendering, from $1.00 at volume; you are billed on successful results only. The volume price starts at 10,000 successful results in one purchase.
What counts as a successful result: a page the site answered with a 2xx status. Blocked requests are retried on new IPs within the request's time limit, and the retries are not billed; blocked pages, timeouts and errors on our side are not billed at all. Whether a site's 404 or 410, or a sign-in page it serves with a 200 status, counts as a result: yes: a target's 404 or 410, and a sign-in page the site serves with a 200 status, are billed results
With JavaScript rendering: $2.00 per 1,000 successful results = $0.002 a page = $2,000 per million pages; from $1.00 per 1,000 ($1,000 per million) at volume. Plain HTTP: $0.50 per 1,000 = $500 per million; from $0.20 ($200 per million). Prices are in US dollars per successful result, not in credits.
One successful result is one billed page, and rendering is a per-request switch with its own price, not a multiplier on a credit balance. To compare a credit-based plan, turn it into dollars: cost per 1,000 pages = plan price ÷ credits in the plan × credits per page × 1,000. Run it once for plain pages and once for rendered ones, and set the results next to $0.50 and $2.00.
| Rate | Entry | Volume, from |
|---|---|---|
| HTTP | $0.50 | $0.20 |
| JS rendering | $2.00 | $1.00 |
Billed on successful results only.
Read moreShow less
| Mode | Per 1,000 successful results | Per page | Per million | At volume, per 1,000 |
|---|---|---|---|---|
| Plain HTTP | $0.50 | $0.0005 | $500 | from $0.20 |
| JavaScript rendering | $2.00 | $0.002 | $2,000 | from $1.00 |
What a month costs at the entry prices (30-day month, one successful result per page):
| Successful results a month | Plain HTTP | With JavaScript rendering |
|---|---|---|
| 1,000 | $0.50 | $2.00 |
| 10,000 | $5.00 | $20.00 |
| 30,000 (1,000 pages a day) | $15.00 | $60.00 |
| 100,000 | $50.00 | $200.00 |
| 300,000 (10,000 pages a day) | $150.00 | $600.00 |
| 1,000,000 | $500.00 | $2,000.00 |
| 3,000,000 (100,000 pages a day) | $1,500.00 | $6,000.00 |
At that scale, bought in one purchase, the volume prices apply: they start at 10,000 results. Prices are in US dollars. Balance for APIs: the same crypto balance as proxies, which never expires; there is no subscription or monthly fee. The minimum top-up is $2.95.
How scraping is billed: per result, per request or per GB
Billing models differ in what you pay for when a page fails. Per-request pricing charges every call; success-based pricing charges only the results you get; proxies charge for the bandwidth or the IP.
| You pay for | Fits | ProxyField |
|---|---|---|
| Each successful result | targets where some pages fail | Web Scraping API: $0.50 per 1,000 (HTTP), $2.00 (JS rendering), billed on success only |
| Bandwidth through the proxy, per GB | your own scraper | residential from $1.95/GB, mobile from $2.45/GB, rotating datacenter from $0.22/GB; traffic never expires |
| A fixed IP for a term | logins and long sessions on one site | dedicated datacenter IPv4 at $1.39 and dedicated ISP from $2.29 per IP for 30 days; renewed by you, no auto-billing |
Proxy purchases are final; in return, your traffic never expires.
Three ways to keep the bill down
- Render only what needs it A page with its content in the HTML costs $0.50 per 1,000 over HTTP; the same page rendered costs $2.00. Test each target both ways, as in JavaScript-heavy sites.
- Deduplicate URLs Strip tracking parameters and keep one copy of each address before you send a batch.
- Fetch only what changed Re-fetch prices daily and descriptions weekly, not everything every run.
Parameters and limits
You choose plain HTTP or JavaScript rendering for each page. country sets the country of the exit IP as a two-letter code; there is no city setting, and the countries it accepts: the proxy pool's 195+ countries. session_id keeps the same exit IP for requests that send the same id, for pages that need one visitor across several requests. The API has no scheduler: your code or tool sends the requests when you need them. Asynchronous jobs, batches of URLs and callbacks: jobs and batches of up to 1,000 requests, with a signed callback for each finished job; results are kept for 48 hours. Concurrency and rate limits: 20 concurrent requests per account; higher limits through sales.
Web scraping API, web unblocker, scraping browser or proxies?
Use the Web Scraping API when you want pages back without running scrapers; use proxies when you already run Scrapy, Playwright or your own code and want to pay per GB or per IP.
| Tool | What you send | What you get back | What you maintain | Sold by ProxyField |
|---|---|---|---|---|
| Web scraping API | a URL | the page | your parser | yes: from $0.20 per 1,000 successful results |
| Web unblocker | requests through a proxy endpoint | the page, with block handling on the provider's side | your scraper | no |
| Scraping browser | browser commands to a remote headless browser | whatever your script reads | your browser script | no |
| Residential and mobile proxies | your own requests | the site's response | scraper, browser, retries | yes: from $1.95/GB and $2.45/GB |
| Datacenter and ISP proxies | your own requests | the site's response | scraper, browser, retries | yes: from $0.22/GB, or at $1.39 and from $2.29 per IP / 30 days |
| Web scraping service | a brief | a dataset | nothing | no |
A search (SERP) API is a narrower tool: it returns search-engine results as data. ProxyField's Google SERP API returns the Google results page as JSON, with the AI Overview, the People Also Ask block and the local pack parsed, for $1.20 per 1,000 successful results, from $0.80.
The longer comparison, with costs per million pages, is in Scraper API vs Proxies.
Web scraping services vs a scraping API
A web scraping service writes and runs the scrapers for you and delivers a dataset; a scraping API gives you the fetching and leaves the choice of pages and fields to you. ProxyField sells the API and the proxies, not a done-for-you service or custom datasets. If you want data without writing a parser, the target APIs come closest: the Google SERP API returns the Google results page as JSON, and the Amazon scraper API returns Amazon product and search pages.
Use it from your code or an AI agent
Your code, or an AI agent that uses the API as a tool, sends the URLs and gets the pages back; parsing and storage stay on your side. Access details are in Request and response. SDKs, an MCP server and agent-framework loaders: none in the first version of the API. MCP options in general are covered in Web Scraping MCP Servers. No-code access: not in the first version of the API.
All scraper APIs
Use a target API when you want one site's results as data; use the Web Scraping API for any other public page. Every API is billed on successful results only.
| API | What it returns | Per 1,000 successful results |
|---|---|---|
| Google SERP API | the Google results page as JSON, with the AI Overview, the People Also Ask block and the local pack parsed | $1.20, from $0.80 |
| Google AI Mode Scraper API | the AI Mode answer | $1.50, from $1.00 |
| ChatGPT scraper API | the ChatGPT answer | $1.50, from $1.00 |
| Perplexity Scraper API | the Perplexity answer | $1.50, from $1.00 |
| Web Scraping API (this page) | any URL, plain HTTP or with JS rendering | HTTP $0.50, from $0.20; JS $2.00, from $1.00 |
| Amazon scraper API | Amazon product and search pages | $0.60, from $0.30 |
| Google Maps Scraper API | Google Maps search results | $1.50, from $1.00 |
The AI Search Scraper API page compares the AI engines side by side. Pages for single sites, such as eBay, Walmart or job boards, show how to collect that site with the Web Scraping API or with proxies: see all scrapers.
Which sites: public pages on any site. Some site categories are restricted to protect the network, including financial and government services.
Run your own scraper on ProxyField proxies
If you would rather keep your own code, ProxyField residential proxies cost from $1.95/GB, with 412M+ residential IPs in 195+ countries and 21,000+ cities, country, region and city targeting, a new IP on every request or sticky sessions from 30 s to 36 h, and HTTP, HTTPS and SOCKS5 on one gateway:
curl -x gate.proxyfield.io:7000 -U "<login>-country-us-city-new_york:<password>" https://api.ipify.orgStart with the Easy Trial: 1 GB for $2.95 (mobile $3.45), with no minimum purchase and no subscription; the traffic never expires and runs on the same pool as a 1 TB order. For sites that accept datacenter traffic, datacenter proxies from $0.22/GB cost less per GB; for one fixed IP per account or session, use ISP proxies. Setup for browsers in code: Playwright with proxies. Proxy choice by job: proxies for web scraping.
Is web scraping legal?
Whether a scrape is lawful depends on the data and how you reach it: logins, access controls, personal data and the site's terms all matter. The longer answer is in Is Web Scraping Legal? and our guides on scraping law. Our Acceptable Use Policy allows collecting public web data, price and SEO monitoring and similar lawful work, and forbids access to data behind logins you are not entitled to. This is not legal advice.
Start with the Web Scraping API
Tell sales which sites you plan to fetch, how many pages a month and how many need rendering. The price is $0.50 or $2.00 per 1,000 successful results, and the volume prices of $0.20 and $1.00 apply from 10,000 results in one purchase.
Web Scraping API FAQ
24/7 support by live chat, including help with setup and integration.
What are the best web scraping APIs for JavaScript-heavy sites?
ProxyField's Web Scraping API renders JavaScript on request for $2.00 per 1,000 successful results, from $1.00 at volume, and fetches plain HTML pages for $0.50. For a JavaScript-heavy site, pick an API that renders per request, so you pay the higher price only on pages that need it, that bills only successful results and that prices in dollars rather than credits: 10,000 rendered pages cost $20.00 here. Fetch each target over plain HTTP first and switch on rendering only where the data is missing.
Is there a free web scraping API good enough for a small hobby project?
ProxyField's Web Scraping API has no free tier, but 1,000 plain pages cost $0.50 and 1,000 rendered pages $2.00, billed on successful results only; 10,000 plain pages cost $5.00 and a 100-page test $0.05. For no software cost at all, run Requests with Beautiful Soup, or Playwright for script-built pages, on your own machine.
What are the best web scraping services if I'd rather pay for the data than build my own scrapers?
ProxyField does not sell finished datasets; for those you need a managed scraping service or a dataset seller. ProxyField's closest option is a target API that returns parsed results, such as the Google SERP API at $1.20 per 1,000 successful results; for any other site, the Web Scraping API returns the page and you parse it.
What is a web unblocker, and is it better than residential proxies?
A web unblocker is a proxy endpoint that adds block handling on the provider's side. Residential proxies are enough for sites that do not block hard. ProxyField sells residential proxies from $1.95/GB and the Web Scraping API, not an unblocker.
How much does a scraper API cost?
ProxyField's Web Scraping API costs $0.50 per 1,000 successful results over HTTP and $2.00 with JavaScript rendering, from $0.20 and $1.00 at volume. 30,000 plain pages a month come to $15.00 at the entry price.
How much does a web scraping API charge per 1,000 pages when JavaScript rendering is turned on?
ProxyField charges $2.00 per 1,000 successful results with JavaScript rendering, from $1.00 at volume, against $0.50 for plain HTTP. That is $0.002 a page, or $2,000 per million rendered pages at the entry price, priced in US dollars per successful result rather than in credits.
How do I compare a credit-based scraping API with a price per 1,000 results?
Turn the credits into dollars: plan price ÷ credits in the plan × credits per page × 1,000 gives the cost per 1,000 pages. Do it once for plain pages and once for rendered ones, because rendered pages usually cost more credits. ProxyField's Web Scraping API is priced in dollars already: $0.50 per 1,000 successful results over plain HTTP and $2.00 with JavaScript rendering.
Does a failed JavaScript render cost anything?
Not on ProxyField's Web Scraping API: it is billed on successful results only, at $2.00 per 1,000 rendered results, so a render that fails is not billed. A blocked page is retried on new IPs, and the retries are not billed either.
How are scraper API results counted for billing?
ProxyField bills the Web Scraping API on successful results only, priced per 1,000: $0.50 over plain HTTP and $2.00 with JavaScript rendering, from $0.20 and $1.00 at volume. A page the site answers with a 2xx status is billed; blocks, timeouts and errors on our side are not, and every response says whether it was billed.
How does a scraper API handle JavaScript rendering?
Rendering runs the page's scripts before the page is returned, so content built in the browser is in the result. With ProxyField you ask for rendering per request, at $2.00 per 1,000 successful results instead of $0.50 for plain HTTP.
Show 12 more questionsShow fewer questions
What data formats does the scraper API return?
ProxyField's Web Scraping API returns the page you asked for as HTML, Markdown or plain text, as a JSON envelope with the status code, final URL, headers, cookies and content, or as a screenshot with rendering. Parsed JSON comes from the target APIs: the Google SERP API returns the Google results page as JSON, with the AI Overview, the People Also Ask block and the local pack parsed.
What is the difference between a scraper API and a scraping browser?
A scraper API takes a URL and returns the page; a scraping browser is a remote headless browser that your script drives step by step, for clicks, logins and forms. ProxyField sells the API, billed per successful result, not a scraping browser.
What is a web scraping service?
A company that builds and runs the scrapers for you and delivers the data, usually priced per project or per dataset. With a scraping API you choose the pages and the fields yourself and pay per result.
Do you offer custom web scraping services?
No. ProxyField does not write custom scrapers or sell datasets; it sells the scraper APIs on this page and the proxies to run your own scrapers.
How do I choose a web scraping API?
Check what counts as a billable result, the price with and without JavaScript rendering, which sites are restricted, and whether the output fits your parser. Then run your own sample of target pages before you commit to a volume.
How can I reduce scraping API costs?
Render JavaScript only on pages that need it ($2.00 instead of $0.50 per 1,000), deduplicate your URLs, and re-fetch only pages that change. You already pay only for successful results.
Can I target a specific country with a scraper API?
Yes: ProxyField's Web Scraping API takes a country setting, a two-letter code for the country of the exit IP; it has no city setting. ProxyField proxies offer 412M+ residential IPs in 195+ countries, with targeting by country, region (state) and city.
Can AI agents use a web scraping API?
Yes: an agent can use a scraping API as a tool that takes a URL and returns the page. ProxyField's Web Scraping API works that way, at $0.50 per 1,000 successful results over plain HTTP, so an agent can call it like any HTTP tool.
Can I use a scraper API without coding?
Some scraper APIs can be called from no-code automation tools. For ProxyField's Web Scraping API, contact sales with your workflow and the number of pages a month before you commit.
What websites can I scrape with the scraper API?
Public pages on any site, not pages behind a login you are not entitled to. Some site categories are restricted to protect the network, including financial and government services.
Can I feed a web scraping API into a data pipeline or dashboard?
Yes: your code sends the URLs, stores each page with the date it was fetched, extracts the fields and loads them into your database or BI tool. The API is the fetching step; the parsing, storage and dashboard stay on your side.
How do I get started with a scraper API?
Contact sales with your target sites, the pages a month and how many need rendering. Sales confirms the price, from $0.50 per 1,000 successful results over HTTP.
Related pages
Web Scraping API, per 1,000 results: HTTP $0.50, JS rendering $2.00
Billed on successful results only. Contact sales for the API and the volume you need. 24/7 live chat helps with setup and integration.