> ## Documentation Index
> Fetch the complete documentation index at: https://docs.nimbleway.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Extract
> Get clean, structured data from any webpage with full control
**Looking for the easiest way to get web data?** [Web Search Agents](/nimble-sdk/agentic/agents) handle everything automatically — no selectors needed. [Try Nimble Studio](https://online.nimbleway.com/workflow-builder) to create an agent for any website in seconds.
Extract is for developers who need full control over CSS selectors, browser actions, and page interactions.
Nimble **Extract** retrieves and parses content from any URL, giving you clean structured data instead of raw HTML.
Point it at a webpage, specify what you want, and get back exactly the information you need - with full JavaScript rendering and anti-bot protection.
## Quick Start
### Example Request
```python Python theme={"system"}
from nimble_python import Nimble
nimble = Nimble(api_key="YOUR-API-KEY")
result = nimble.extract(
url= "https://www.google.com/search?q=nimble",
render= True
)
print(result.data.html)
```
```javascript Node theme={"system"}
import Nimble from "@nimble-way/nimble-js";
const nimble = new Nimble({ apiKey: "YOUR-API-KEY" });
const result = await nimble.extract({
url: "https://www.google.com/search?q=nimble",
render: true,
});
console.log(result.data.html);
```
```bash cURL theme={"system"}
curl -X POST 'https://sdk.nimbleway.com/v1/extract' \
--header 'Authorization: Bearer ' \
--header 'Content-Type: application/json' \
--data-raw '{
"url": "https://www.google.com/search?q=nimble",
"render": true
}'
```
### Example Response
```json theme={"system"}
{
"url": "https://www.example.com",
"task_id": "b1fa7943-cba5-4ec2-a88c-4d2d6799c794",
"status": "success",
"data": {
"html": "...",
"headers": {}
},
"metadata": {
"query_time": "2026-02-08T22:00:36.132Z",
"query_duration": 1877,
"driver": "vx8"
},
"status_code": 200
}
```
## How it works
Give Extract the webpage URL and configure rendering, parsing, or browser
actions
* Loads the webpage with optional JavaScript rendering if enabled - Handles
cookies, headers, and authentication - Bypasses anti-bot protections with
stealth mode - Renders dynamic content completely
* Returns content in your chosen format (HTML, markdown) - Parses structured
data using your CSS selectors (if parsing schema provided) - Captures
network requests if configured
Get clean JSON with your extracted data, ready to use in your application
## Parameters
Supported input parameters:
The webpage URL to extract content from.
**Example:** `https://www.example.com/product`
Enable JavaScript rendering for dynamic content.
Set to `true` for sites built with React, Vue, Angular, or other JavaScript frameworks.
The extraction engine to use.
**Options:**
* `vx6` - Fast HTTP requests (no JavaScript)
* `vx8` - Headless browser with JavaScript
* `vx8-pro` - Headful browser with JavaScript
* `vx10` - Stealth headless browser
* `vx10-pro` - Stealth headful browser
Output formats to return.
**Options:**
* `html` - Raw HTML content
* `markdown` - Converted markdown format
* `screenshot` - Full-page screenshot as base64-encoded PNG
* `headers` - HTTP response headers returned by the server (`data.headers`)
**Example:** `["html", "markdown"]`
Extract content as if visiting from a specific country. Use ISO Alpha-2 codes.
**Examples:** `US`, `UK`, `DE`, `FR`
For US locations, you can specify a specific state. Only works in US or CA.
Use ISO Alpha-2 codes like `NY`, `FL`, etc.
**Example:**
```json theme={"system"}
"state": "CA"
```
Target a specific city for hyper-local content. Works with most major cities worldwide.
**Example:**
```json theme={"system"}
"city": "New York"
```
Replace spaces from city names with underscore (e.g,`New York` becomes `new_york`).
Set the browser's language preference. Affects how websites display content to you.
Use LCID standard codes like `en-US`, `en-GB`, `fr-FR`, `de-DE`, etc.
**Example:**
```json theme={"system"}
"locale": "en-US"
```
CSS selectors for structured data extraction. Define field names with selectors and optional types.
**Example:**
```json theme={"system"}
{
"parser":
{
"product_name":
{
"type": "terminal",
"selector":
{
"type": "css",
"css_selector": ".product-title"
},
"extractor":
{
"type": "text"
}
},
"price":
{
"type": "terminal",
"selector":
{
"type": "css",
"css_selector": ".price-value"
},
"extractor":
{
"type": "text",
"post_processor":
{
"type": "number"
}
}
}
}
}
```
Automate browser interactions before extraction. Supports click, scroll, wait, type, and more.
**Example:**
```json theme={"system"}
[
{"click": {"selector": "#load-more"}},
{"wait": {"duration": 2000}}
]
```
Capture API calls and network requests during page load. Specify URL patterns to intercept.
**Example:**
```json theme={"system"}
{
"url": "https://www.example.com",
"render": true,
"network_capture":
[
{
"method": "GET",
"url":
{
"type": "exact",
"value": "https://www.example.com/api/data"
}
}
]
}
```
Add custom HTTP headers to your request. Useful for authentication or custom user agents.
**Example:**
```json theme={"system"}
"headers": {
"User-Agent": "Custom Bot 1.0",
"X-API-Key": "your-key"
}
```
Set cookies before loading the page. Great for accessing logged-in content or maintaining sessions.
Each cookie needs a `key`, `value`, and `domain`.
**Example:**
```json theme={"system"}
"cookies": [
{
"key": "session_id",
"value": "abc123xyz",
"domain": "example.com"
}
]
```
## Usage
### Basic HTML extraction
Extract HTML content from any URL:
```python Python theme={"system"}
from nimble_python import Nimble
nimble = Nimble(api_key="YOUR-API-KEY")
result = nimble.extract(
url= "https://www.google.com/search?q=nimble"
)
html = result.data.html
print(html)
```
```javascript Node theme={"system"}
import Nimble from "@nimble-way/nimble-js";
const nimble = new Nimble({ apiKey: "YOUR-API-KEY" });
const result = await nimble.extract({
url: "https://www.google.com/search?q=nimble",
});
const html = result.data.html;
console.log(html);
```
```bash cURL theme={"system"}
curl -X POST 'https://sdk.nimbleway.com/v1/extract' \
--header 'Authorization: Bearer ' \
--header 'Content-Type: application/json' \
--data-raw '{
"url": "https://www.google.com/search?q=nimble"
}'
```
### JavaScript rendering
Enable rendering for dynamic sites (React, Vue, etc.):
```python Python theme={"system"}
from nimble_python import Nimble
nimble = Nimble(api_key="YOUR-API-KEY")
result = nimble.extract(
url= "https://www.nimbleway.com/sdk",
render= True
)
print(result.data.html)
```
```javascript Node theme={"system"}
import Nimble from "@nimble-way/nimble-js";
const nimble = new Nimble({ apiKey: "YOUR-API-KEY" });
const result = await nimble.extract({
url: "https://www.nimbleway.com/sdk",
render: true,
});
console.log(result.data.html);
```
```bash cURL theme={"system"}
curl -X POST 'https://sdk.nimbleway.com/v1/extract' \
--header 'Authorization: Bearer ' \
--header 'Content-Type: application/json' \
--data-raw '{
"url": "https://www.nimbleway.com/sdk",
"render": true
}'
```
### Stealth mode
Bypass anti-bot protections with stealth driver:
```python Python theme={"system"}
from nimble_python import Nimble
nimble = Nimble(api_key="YOUR-API-KEY")
result = nimble.extract(
url= "https://www.protected-site.com",
render= True,
driver= "vx10"
)
print(result.data.html)
```
```javascript Node theme={"system"}
import Nimble from "@nimble-way/nimble-js";
const nimble = new Nimble({ apiKey: "YOUR-API-KEY" });
const result = await nimble.extract({
url: "https://www.protected-site.com",
render: true,
driver: "vx10",
});
console.log(result.data.html);
```
```bash cURL theme={"system"}
curl -X POST 'https://sdk.nimbleway.com/v1/extract' \
--header 'Authorization: Bearer ' \
--header 'Content-Type: application/json' \
--data-raw '{
"url": "https://www.protected-site.com",
"render": true,
"driver": "vx10"
}'
```
### Parsing with CSS selectors
Extract structured data with a parsing schema:
```python Python theme={"system"}
from nimble_python import Nimble
nimble = Nimble(api_key="YOUR-API-KEY")
result = nimble.extract(
url= "https://www.amazon.com/s?k=iphone+17",
parser= {
"title": {
"selector": "h1.product-title"
},
"price": {
"selector": ".price",
"type": "number"
},
"in_stock": {
"selector": ".availability",
"type": "boolean"
}
}
)
parsed = result.data.parsing
print(f"Title: {parsed['title']}")
print(f"Price: {parsed['price']}")
```
```javascript Node theme={"system"}
import Nimble from "@nimble-way/nimble-js";
const nimble = new Nimble({ apiKey: "YOUR-API-KEY" });
const result = await nimble.extract({
url: "https://www.example.com/product",
render: true,
parsing: {
title: { selector: "h1.product-title" },
price: { selector: ".price", type: "number" },
in_stock: { selector: ".availability", type: "boolean" },
},
});
const parsed = result.data.parsing;
console.log(`Title: ${parsed.title}`);
console.log(`Price: ${parsed.price}`);
```
```bash cURL theme={"system"}
curl -X POST 'https://sdk.nimbleway.com/v1/extract' \
--header 'Authorization: Bearer ' \
--header 'Content-Type: application/json' \
--data-raw '{
"url": "https://www.example.com/product",
"render": true,
"parsing": {
"title": { "selector": "h1.product-title" },
"price": { "selector": ".price", "type": "number" },
"in_stock": { "selector": ".availability", "type": "boolean" }
}
}'
```
### Browser actions
Automate interactions before extraction:
```python Python theme={"system"}
from nimble_python import Nimble
nimble = Nimble(api_key="YOUR-API-KEY")
result = nimble.extract(
url="https://www.nimbleway.com/blog",
render=True,
browser_actions=[{"wait": 2000}, {"scroll": 500}]
)
print(result.data.html)
print(f"Browser Actions: {result.data.browser_actions}")
```
```javascript Node theme={"system"}
import Nimble from "@nimble-way/nimble-js";
const nimble = new Nimble({ apiKey: "YOUR-API-KEY" });
const result = await nimble.extract({
url: "https://www.nimbleway.com/blog",
render: true,
browser_actions: [{ wait: 2000 }, { scroll: 500 }],
});
console.log(result.data.html);
console.log(`Browser Actions: ${result.data.browser_actions}`);
```
```bash cURL theme={"system"}
curl -X POST 'https://sdk.nimbleway.com/v1/extract' \
--header 'Authorization: Bearer ' \
--header 'Content-Type: application/json' \
--data-raw '{
"url": "https://www.nimbleway.com/blog",
"render": true,
"browser_actions": [
{"wait": 2000 },
{"scroll": 500 }
]
}'
```
### Geo-targeting
Extract content from specific locations:
```python Python theme={"system"}
from nimble_python import Nimble
nimble = Nimble(api_key="YOUR-API-KEY")
result = nimble.extract(
url= "https://ipinfo.io/json",
country= "GB",
locale= "en-GB"
)
print(result.data.html)
```
```javascript Node theme={"system"}
import Nimble from "@nimble-way/nimble-js";
const nimble = new Nimble({ apiKey: "YOUR-API-KEY" });
const result = await nimble.extract({
url: "https://ipinfo.io/json",
country: "GB",
locale: "en-GB",
});
console.log(result.data.html);
```
```bash cURL theme={"system"}
curl -X POST 'https://sdk.nimbleway.com/v1/extract' \
--header 'Authorization: Bearer ' \
--header 'Content-Type: application/json' \
--data-raw '{
"url": "https://ipinfo.io/json",
"country": "GB",
"locale": "en-GB"
}'
```
## Drivers
Choose the right extraction engine for your needs:
| Driver | Description | Best For | Render |
| ---------- | -------------------------- | ------------------------------ | ------ |
| `vx6` | Fast HTTP requests (no JS) | Static HTML, APIs, high volume | No |
| `vx8` | Headless browser with JS | Dynamic sites, SPAs | Yes |
| `vx8-pro` | Headful browser with JS | Complex interactions | Yes |
| `vx10` | Stealth headless browser | Bot-protected sites | Yes |
| `vx10-pro` | Stealth headful browser | Most protected sites | Yes |
## Response Fields
| Field | Type | Description |
| --------------- | ------ | --------------------------------------- |
| `url` | string | The requested URL |
| `task_id` | string | Unique identifier for the request |
| `status` | string | `success` or `failed` |
| `data.html` | string | Extracted HTML content |
| `data.markdown` | string | Content as markdown (if requested) |
| `data.parsing` | object | Structured data (if parsing configured) |
| `status_code` | number | HTTP status code from target |
## Blocked Domains
Requests targeting the following domains are blocked and will be rejected.
* `*.paypal.com`
* `account.sonyentertainmentnetwork.com`
* `acopic.click`
* `adskpak.com`
* `amctheatres.com`
* `andromedabee.com`
* `antliabee.co.uk`
* `api.groupon.com`
* `api.stripe.com`
* `api.tyrads.com`
* `apusbee.co.uk`
* `auth.api.sonyentertainmentnetwork.com`
* `bellarmine.click`
* `caixa.gov.br`
* `callofduty.com`
* `canal-plus.com`
* `clubmium.com`
* `clubmium.net`
* `couponcabin.com`
* `crunchyroll.com`
* `dazn.com`
* `directv.com`
* `ea.com`
* `epicgames.com`
* `fustian.click`
* `gomobile.it`
* `googlecm.hit.gemius.pl`
* `hbo.com`
* `hitspro.net`
* `honeyga.in`
* `honeygain.com`
* `honeygain.money`
* `hotstar.com`
* `iplogger.org`
* `kayak.com`
* `mojang.com`
* `mte.gov.br`
* `music-box.mobi`
* `mybip.it`
* `myy.io`
* `native.np.ac.playstation.net`
* `networkcontroller.net`
* `ocmey.com`
* `onevanilla.com`
* `ordo.link`
* `pagseguro.com`
* `paypal.com`
* `playstation.com`
* `playstation.net`
* `plex.tv`
* `powerbrowsing.online`
* `revenuevelocity.eu`
* `roblox.com`
* `runescape.com`
* `seasyvendas.com`
* `sky.com`
* `sport4life.mobi`
* `spotify.com`
* `ssfcu.com`
* `steamcommunity.com`
* `steampowered.com`
* `torrentdownloads.me`
* `ttvnw.net`
* `tyrads.com`
* `tyrrewards.com`
* `ubi.com`
* `ubisoft.com`
* `unrealengine.com`
* `usps.com`
* `valuedopinions.com`
* `vrv.co`
* `wellsfargo.com`
* `www.ltv-mob.com`
* `yogini.top`
* `zelator.in`
## Use cases
Full control for data extraction at high scale with precise selectors and
configurations
Handle JavaScript-heavy sites that require full page rendering
Bypass anti-bot protections with stealth mode and residential proxies
Extract structured data using CSS selectors and parsing schemas
## Extract vs other tools
| What you need | Use |
| ---------------------------------------------- | ----------------------------------------------------------------------------- |
| Data from popular sites (Amazon, Google, etc.) | [**Public Agent**](/nimble-sdk/agentic/agent-gallery) - maintained by Nimble |
| Data from sites not in the gallery | [**Custom Agent**](/nimble-sdk/agentic/studio) - create with natural language |
| Data from specific URLs (expert users) | **Extract** - full control with CSS selectors |
| Data from entire website | [**Crawl**](/nimble-sdk/web-tools/crawl) |
| Search web + extract content from results | [**Search**](/nimble-sdk/web-tools/search) |
**For most users**, we recommend starting with [Web Search
Agents](/nimble-sdk/agentic/agents) - pre-built extractors maintained by
Nimble for popular sites. Use Extract when you need full control over
selectors and page interactions.
## Features
Explore detailed documentation for each Extract feature:
asynchronous processing and long-running operations
HTML, markdown, and text output options
Extract from specific countries, states, or cities
Enable JavaScript for dynamic websites
Bypass anti-bot systems
Automate clicks, scrolling, form filling
Define CSS selectors for structured data
Intercept API calls and AJAX requests
Send custom headers and cookies
## Next steps
Create a Web Search Agent for any website — no CSS selectors needed
Use Nimble in Claude Code or Cursor
Explore endpoints, request parameters, and response schemas for the Extract
API
Learn about intelligent agents that handle extraction automatically