A URL in. A readable page out.
Send a public HTTPS URL. A fresh browser runs the page's JavaScript, waits for the content you name, and returns rendered HTML, readable text, links, and a full receipt.
AlphaHosted at unblock.vitna.ai · key issued on request · billing not active

A requestwaits for the line in amber
POST /v1/unblock- url
- scrapingcourse.com/javascript-rendering
- waitFor
- .product-item:nth-child(12) .product-name
What came back5 Oct 2026 · local
12 of 12product names, in 1.34 s
- Chaz Kangeroo Hoodie $52
- Teton Pullover Hoodie $70
- Bruno Compete Hoodie $63
Three workloads, one request.
Choose a workload, read what comes back, and take the request in JavaScript, Python or cURL. The examples are illustrative; Live API mode sends a real request through vitna.ai's relay and needs an alpha key (vitna_unblock_…) or your org's Vitna key (vitna_key_…).
Give a research agent readable documentation or article content, with links it can use to follow the source. Wait for the article or main content to appear.
Illustrative content. A live request needs an alpha key.
Example documentation
Quickstart The documentation added by JavaScript is ready to read. API reference
https://example.com/docs/api- Rendering
- JavaScript executed
- Delivery
- 1 attempt
- HTTP status
- 200
Illustrative snapshot. No live request has been sent.
const response = await fetch(
"https://unblock.vitna.ai/v1/unblock",
{
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${process.env.VITNA_UNBLOCKER_KEY}`
},
body: JSON.stringify({
"url": "https://example.com/docs/quickstart",
"render": true,
"output": "json",
"timeoutMs": 30000,
"waitFor": "main"
})
}
);
const page = await response.json();The same URL, twice.
A public training catalog loads its 12 products with JavaScript. Fetched as it is served, the page is a shell. Through the Unblocker, a browser runs the script, waits for the twelfth product, and returns the page.
render: falsethe page as it is served
0product names
- Slot 1: empty
- Slot 2: empty
- Slot 3: empty
- Slot 4: empty
- Slot 5: empty
- Slot 6: empty
- Slot 7: empty
- Slot 8: empty
- Slot 9: empty
- Slot 10: empty
- Slot 11: empty
- Slot 12: empty
“Enable JavaScript to see products”
render: truethrough the Unblocker
12product names, in 1.34 s
- Chaz Kangeroo Hoodie$52
- Teton Pullover Hoodie$70
- Bruno Compete Hoodie$63
- Frankie Sweatshirt$60
- Hollister Backyard Sweatshirt$52
- Stark Fundamental Hoodie$42
- Hero Hoodie$54
- Oslo Trek Hoodie$42
- Abominable Hoodie$69
- Mach Street Sweatshirt$62
- Grayson Crewnec…in the HTML
nth-child(12)waited for
“JS Rendering Challenge to Learn Web Scraping - ScrapingCourse.com”
- delivered
- true
- duration
- 1.34 s
- attempts
- 1
- requests
- 11, 18 blocked
- transferred
- 386 KB
- challenge
- none
Recorded locally on 5 October 2026, on Windows with Microsoft Edge 154.0.4258.53, a fresh session and a direct route, not through unblock.vitna.ai: one rendered request and one with rendering off, not a benchmark. The excerpt is the API's own, cut at 320 characters; product names were checked against the captured page. Download the capture record
A page, or a reason.
Every response is one or the other. A page is delivered only after the checks pass, with a receipt of how it was read. Anything else is refused with a code and the attempts it took, never passed off as a page.
content.html- The rendered page, after its scripts ran, up to 2 MiB.
content.text- The readable text, without the markup.
content.links- The page's public HTTPS links, made absolute and de-duplicated.
meta.delivered- True only once the page passed the delivery checks.
meta.attempts- Each attempt, its outcome and the route it took.
meta.challenge- Whether a challenge appeared, cleared, and how long it took.
meta.network- Requests made and blocked, and the bytes transferred.
selector_timeout502Check the selector against the rendered page, not the source.
target_challenge502Retried in a fresh browser while your retries last. A challenged page is never delivered.
target_incomplete502Name the element you need in waitFor, so readiness is yours to say.
target_timeout504Raise timeoutMs within the deadline GET /v1/status reports for your key, or try again later.
Under the proposed pricing a refused page would consume no paid unit, though it still counts against your key's rate limit. Every code the service returns is in the error contract.
Hosted, with an alpha key.
The service answers at unblock.vitna.ai. An alpha key is issued on request once a person has checked the fit, and the first request reads the same JavaScript page the recorded run read.
Hosted alphaA request is read by a person; it starts no plan and no subscription, and a key is issued once the fit is confirmed.
- 1
Request access.
Bring one workload: public target URLs, the content you need, and a monthly volume, in the form at the foot of the page. Targets, limits and pricing are agreed before any paid use.
- 2
Receive the key.
The key starts
vitna_unblock_and is sent as a bearer token. Keep it on your server, in an environment file outside version control; a key in a browser page or a repository is anyone's..envVITNA_UNBLOCKER_KEY=vitna_unblock_PASTE_YOUR_KEY - 3
Make the first request.
Save the request as
first-page.mjsand run it with Node. A delivered response prints the page's text and its receipt; a refusal prints its status and code. The site's relay,https://vitna.ai/api/v1/unblock, takes the same request and key.first-page.mjsconst response = await fetch("https://unblock.vitna.ai/v1/unblock", { method: "POST", headers: { "Content-Type": "application/json", Authorization: `Bearer ${process.env.VITNA_UNBLOCKER_KEY}`, }, body: JSON.stringify({ url: "https://www.scrapingcourse.com/javascript-rendering", render: true, output: "json", waitFor: ".product-item:nth-child(12) .product-name", timeoutMs: 30000, retries: 0, }), signal: AbortSignal.timeout(35000), }); const page = await response.json(); if (!response.ok || page.meta?.delivered !== true) { console.error(response.status, page.error?.code, page.error?.message); process.exitCode = 1; } else { console.log(page.content.text); console.log(JSON.stringify(page.meta, null, 2)); }Run itnode --env-file=.env first-page.mjs - 4
Read your limits.
GET /v1/statusanswers with the limits that apply to your key, what it has used of them today, and that billing is not enabled. It renders nothing and spends none of your allowance.Statuscurl https://unblock.vitna.ai/v1/status \ -H "Authorization: Bearer $VITNA_UNBLOCKER_KEY"
If the first request needs a fixA 401, a 429, a selector that never appears, or a challenge that stays.
- 401 unauthorized
- The key is missing or not one the service holds. Send it as
Authorization: Bearer vitna_unblock_…, or your org'svitna_key_…, exactly as it was issued. - 429 rate_limited or daily_limit
- Your key has used its allowance for the minute or for the UTC day. Wait the seconds the
Retry-Afterheader gives;GET /v1/statusshows what is left. - 429 service_busy
- Every browser slot is in use. Try again after the
Retry-Afterheader. - 502 selector_timeout
- The element never became visible. Check the selector against the rendered page, not the source.
- 502 target_challenge
- The page still showed a browser challenge after the wait. It is refused rather than delivered, and the alpha cannot reach every site.
Every other code, and the status it comes with, is in the error contract.
Three jobs, one field each.
The rest of the request stays the same: a public URL, rendering on, a deadline. What changes from one job to the next is one field, shown here as you would write it. The selectors are examples.
- 01
Research agents
An agent should cite what a reader sees, not the shell a plain fetch returns. Name the element that holds the article and the snapshot waits until it is visible. The text leaves out navigation and scripts, and the links come back absolute, so the agent can follow a source.
"waitFor": "main article" - 02
Product extraction
A catalog filled by script, read as the rendered HTML beside its text and links, for the extraction code you already run. Wait for the last populated product rather than its loading card, as the recorded run waited for the twelfth. The service returns the page; it infers no product fields.
"output": "json" - 03
Pages that need a step first
A consent banner to dismiss, a load-more button to press, a search box to fill. Up to 50 ordered steps run before the snapshot. Only GET requests leave the browser, so a search form that uses GET works and a form that posts fails with navigation_blocked.
"actions": [{ "type": "click", "selector": "#accept" }]
One request, one fresh browser.
The Unblocker is a service of its own on Vitna's server, apart from the website. You integrate it as one HTTPS call; the browser, its limits and its cleanup are on our side.
POST /v1/unblockBearer token8 KiB body capPer-minute and daily allowances checked before any browser starts. Over limit: 429 Retry-After.
Public HTTPS only, pinned DNS answers, GET-only guard, no images/fonts/media fetched.
Plus structured receipt with timing and attempts.
Challenged, empty, or blocked: never silently delivered.
your codeOne HTTPS POST
A JSON body and your key as a bearer token, from any language with an HTTP client. Nothing to install and nothing to run on your side.
unblock.vitna.ai/v1/unblockor vitna.ai/api/v1/unblockThe hosted endpoint, or the site's relay
The endpoint answers directly. The relay on vitna.ai takes the same request, forwards your key unchanged, refuses a body over 8 KiB, and does no browser work itself.
admissionYour key, and its allowance
The service checks the key, then admits the request against your key's per-minute and daily allowances, counted across its processes. Over either, the answer is 429 with Retry-After, before any browser starts.
a fresh browserOn Vitna's server, apart from the website
A browser of its own for every attempt, in a service that shares no database or keys with the website. It reaches public HTTPS pages only, every DNS answer checked and pinned into the connection, and only GET requests leave it.
the answerA page, or a reason
A delivered page with its receipt, or a refusal with its code and every attempt it took. The service logs one line per request, the target's host and the outcome, never the page.
Inside each attempt
- 01
Render
A fresh browser for every attempt. Its cookies end with it, unless you name a session and ask to keep it. Images, fonts and media are not fetched.
render: true - 02
Wait
For the selector you name to become visible, or, with none, for the page to settle enough to read.
waitFor - 03
Check
A recognized browser challenge gets up to 12 seconds. A page still challenged, empty or loading is refused, never delivered.
meta.challenge - 04
Deliver
The rendered HTML, the readable text and the links, with a receipt: attempts, timing, network and any challenge.
meta.delivered
Against Bright Data, request by request.
100 requests to each, one mark a request.
Not the hosted alphaThe hosted alpha at unblock.vitna.ai runs the native profile, which this run did not measure.
VitnaCloakBrowser 146 profile99 of 100
Bright DataWeb Unlocker87 of 100
Time to a verified page, each request once
- Pages
- 10 public demo pages on 3 training domains, 10 rounds each
- Counted
- Only when the page's expected rendered content arrived; an HTTP 200 without it failed
- Load
- 4 in flight per provider, a 60-second deadline on each
- Vitna
- CloakBrowser 146, on the caller's own server, a fresh browser per request, waiting for a selector on each page
- Bright Data
- Web Unlocker's remote API with forced rendering; its cache, browser version and retries not observed
- Run
- 3 October 2026, both batches from one Linux server
A small repeated workload with different readiness rules, routes and transport. It describes this test, not the wider web, and not the hosted alpha.
The full results and the methodBoth batches, by category, with how the run was set up and what failed.
| Measured | Vitna, CloakBrowser 146 profile | Bright Data, Web Unlocker |
|---|---|---|
| Content verified | 99 of 100 | 87 of 100 |
| JavaScript pages | 50 of 50 | 40 of 50 |
| Static pages | 30 of 30 | 29 of 30 |
| Challenge pages | 19 of 20 | 18 of 20 |
| Median, verified | 1.17 s | 18.05 s |
| 95th percentile, verified | 11.28 s | 45.03 s |
| Whole batch | 1m 18s | 8m 45s |
100 requests per provider, 4 in flight at a time, a 60-second deadline on each. Both batches started from one Linux VPS. Vitna's service ran on that same machine, on CloakBrowser 146, a fresh session per request and a direct connection, so the caller's calls to its API never left the machine; Bright Data's remote API used forced browser rendering. The hosted alpha runs the native profile instead, and this run says nothing about it.
What failed. Vitna: target_challenge. Bright Data: 10 incomplete_content, 2 target_http_error, 1 request_timeout.
Where the alpha stops.
What one request may spend, and the boundaries every request meets on the hosted service. Your key's own allowance and deadline ceiling are not printed here: GET /v1/status reports both.
- Deadline
- 30 s
- by default; the contract's ceiling is 60 s, GET /v1/status reports your key's, and retries share it
- Retries
- 1
- by default, 2 at most, each in a fresh browser
- Resource requests
- 400
- per attempt; images, fonts and media are not fetched
- Transfer
- 20 MiB
- per attempt, both directions
- Rendered HTML
- 2 MiB
- per response
- Challenge wait
- 12 s
- per attempt, with at most 2 clicks on a visible verification checkbox
- Browser actions
- 50
- ordered steps per request
- Request body
- 8 KiB
- at the service and at the relay
- Destinations
- Public HTTPS pages only. IP literals, internal names and addresses, credential-bearing URLs, plain HTTP, custom ports and private redirects are refused.
- Methods
- Only GET requests leave the browser, apart from a recognized challenge's own verification. A form that posts, a sign-in or a purchase fails with navigation_blocked.
- Sign-in
- None. The API takes no credentials, cookies or arbitrary headers, so pages behind a login are outside the alpha.
- Browser
- The hosted alpha runs the native profile. The CloakBrowser profile in the benchmark is not part of it.
- Your key's allowance
- A per-minute and a daily allowance, with refused requests counted. Past either, 429 rate_limited or daily_limit with a Retry-After header. GET /v1/status prints your key's own figures.
- Browser slots
- A fixed number of browsers run at once. When all are busy, 429 service_busy with Retry-After.
- Reach
- Not every site. A page that stays challenged is refused, and the benchmark covers ten public demo pages, not the web at large.
One unit: a delivered page.
A page counts once it is delivered, its retries included. A refused page costs no unit, so a block, a timeout or a selector that never appears is not billed; the request still counts against your key's rate limit.
Not for sale yetThese are proposed rates for the hosted alpha. Billing is not active, and nobody can pay.
Trial
Freeonce
500 delivered pages, to try one workload
Pay as you go
$2per 1,000 pages
No monthly commitment
Builder
$29a month
20,000 pages included, then $1.50 per 1,000
$1.45 per 1,000 at full use
Growth
$99a month
100,000 pages included, then $1 per 1,000
$0.99 per 1,000 at full use
- Every plan renders JavaScript, waits on a selector, and returns HTML, text, links and the receipt.
- The hosted plans would carry a monthly spending cap, with overage only if you opt in.
Estimate a monthEnter a monthly volume and compare the three paid plans at the proposed rates.
Up to 1,000,000. Ask for access above that.
$29.00a month on Builder, the lowest
- Pay as you go
- $40.00
- Builder
- $29.00
- Growth
- $99.00
In USD, before tax, at the proposed rates. Excludes the one-time trial. It creates no subscription.
What it costs to run
- Vitna's chargeNot active
Proposed per delivered page, at the rates above. Billing is off and nobody can pay.
- Browsers and serversVitna
The hosted alpha runs the browsers on Vitna's own server. You host nothing and buy no hardware for it.
- Proxy providerNone
The hosted alpha connects to pages directly, with no proxy provider in the path, so no third-party proxy charge reaches you.
- Residential routes, CAPTCHA solvingNot offered
Neither is part of the alpha. Either would be priced on its own.
- Refused pagesNo unit
A block, a timeout or a missing selector consumes no paid unit, but each request still counts against your key's rate limit.
- Reading the pageYou
The code that calls the API, and whatever reads the page afterwards, such as a model and its provider's tokens.
What the alpha does, and does not.
The short answers. The full documentation has the request contract and the error codes.
What counts as a delivered page?A good response, readable content, no challenge left, and your selector visible.
The service checks the page's response, its readable content and recognized challenge markup. A selector you name must become visible before the snapshot is taken, so name an element that holds the content you need. Delivery does not validate every field your application reads.
How do I get a key, and keep it safe?A person issues an alpha key after the fit check. It is a bearer token.
Request access at the foot of the page. Once the fit is confirmed you receive a key that starts vitna_unblock_, sent as Authorization: Bearer to unblock.vitna.ai or to vitna.ai's relay. If your org already holds a Vitna key, which starts vitna_key_, it works here as an alpha key does. The service keeps only a SHA-256 hash of an alpha key, so a lost key cannot be read back; ask for a new one through the contact form. Keep it on your server, never in a page a browser loads or in a repository.
The key is the only credential the API takes. It accepts no passwords, cookies or tokens for the sites you read.
What does the service keep?A receipt line per request, with the target's host and never the page.
Each request is logged with your key's client name, the target's hostname, the outcome, the attempt count and the duration. The log leaves out URL paths and queries, keys and the content fetched, and no search index or archive of pages is written. The one thing kept between requests is a session you ask it to keep, below.
The access form stores your email, workload and volume to scope access. Share public URLs there, never credentials or private pages.
Can I read pages behind a login, or reuse cookies?Not behind a login. A named session can keep a page's own cookies, if you ask.
The API takes none of your cookies or credentials and runs no login flow, so logged-in pages are outside the alpha. Every attempt starts a fresh browser. Name a session and set persistSession to true, and the service saves that page's own cookies and localStorage for your key and that session, for 15 minutes after each successful save; DELETE /v1/sessions/ with the session's name clears it sooner. Application POST loading and WebSockets are outside the contract.
Will it get past every anti-bot system?No. Recognized browser verification gets a bounded wait, and what stays challenged is refused.
A recognized challenge gets up to 12 seconds per attempt, and a visible Cloudflare verification checkbox at most 2 clicks. During a challenge it fills no forms and solves no image puzzles; a form that posts fails with navigation_blocked. The benchmark above covers ten public demo pages, not the web at large, and it ran a browser profile the hosted alpha does not.
Does it return structured product data?It returns the page. Your application extracts the fields.
The JSON output carries the rendered HTML, the readable text, the links and the receipt. Schema extraction, or a model reading the page, stays on your side; the alpha infers no product fields.
Are proxies and CAPTCHA solving included?No. The hosted alpha connects to pages directly.
The hosted alpha reaches each page over a direct connection from Vitna's server, with no proxy route in the path. Managed residential capacity and image CAPTCHA solving are not offered, and either would be priced on its own.
Can I buy hosted access today?Not yet. Hosted access is by alpha key today, nothing is billed, and the pricing on this page is proposed.
Request alpha access with one representative workload and we will scope the fit. An interest request creates no subscription and no charge.
Where do I get help?Talk to us, through the contact form.
Write through the contact form, with the request ID and the error code from the response. The same form is where to ask for a new key.
Alpha access
Bring one page.
Tell us the page and the content that makes it useful. One recurring workload is enough to scope access, and the answer comes from a person.
- Describe the pages and the content you need.
- We check the fit against what the alpha does today.
- Access, limits and pricing are confirmed before any paid use.
