> ## 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.

# Max Driver

> Run every Extract driver at once and get the first successful response

The `max` driver sends one request to every Nimble driver at the same time and returns the first successful response. Use it when speed and success rate matter more than cost.

Common uses:

* **Latency-sensitive agents**: get the page back as fast as any driver can fetch it.
* **Hard targets**: let stealth and rendering drivers race instead of escalating one at a time.
* **Unknown sites**: skip driver tuning when the site mix changes from request to request.

> [!NOTE]
>
> `max` is a premium driver billed at \$2.50 per 1K URLs. Only the successful response is charged. Failed requests are free. See [Pricing](https://docs.nimbleway.com/nimble-sdk/admin/pricing.md).

## Quick Start

### Example Request

```python Python theme={"system"}
from nimble_python import Nimble

nimble = Nimble(api_key="YOUR-API-KEY")

result = nimble.extract.run(
    url="https://www.example.com",
    driver="max"
)

print(result.data.html)
```

```typescript TypeScript theme={"system"}
import Nimble from "@nimble-way/nimble-js";

const nimble = new Nimble({ apiKey: "YOUR-API-KEY" });

const result = await nimble.extract.run({
  url: "https://www.example.com",
  driver: "max",
});

console.log(result.data?.html);
```

```bash cURL theme={"system"}
curl -X POST 'https://sdk.nimbleway.com/v2/extract' \
--header 'Authorization: Bearer <YOUR-API-KEY>' \
--header 'Content-Type: application/json' \
--data-raw '{
    "url": "https://www.example.com",
    "driver": "max"
}'
```

```bash CLI theme={"system"}
nimble extract run \
  --url "https://www.example.com" \
  --driver max
```

### Example Response

```json theme={"system"}
{
  "url": "https://www.example.com",
  "task_id": "b1fa7943-cba5-4ec2-a88c-4d2d6799c794",
  "status": "success",
  "data": {
    "html": "<!DOCTYPE html><html>...</html>",
    "headers": {}
  },
  "metadata": {
    "query_time": "2026-11-03T09:12:41.207Z",
    "query_duration": 1412,
    "driver": "max"
  },
  "status_code": 200
}
```

## How it works

**1. You send one request with driver: max**

Pass `driver: "max"` with the URL. No other driver settings are needed.

**2. Nimble starts every driver at the same time**

The request is sent to all drivers in parallel, from plain HTTP (`vx6`) to stealth headful browsers (`vx10-pro`). Each driver uses its own rendering settings.

**3. The first successful response wins**

As soon as one driver returns a valid page, that response is sent back to you. Slower attempts keep running in the background. They do not delay the response and are not charged.

**4. Failures are reported only if every driver fails**

If no driver succeeds, the request fails once with the final error. Failed requests are not charged.

## Parameters

> [accordion] driver
>
> **driver** `string`
>
> Set to `"max"` to run every driver in parallel and return the first successful response.
>
> **Works with:** `formats`, `country`, `state`, `city`, `locale`, `parse`, `headers`, `cookies`, and `request_timeout`.
>
> **Cannot be combined with:** `render: "auto"` or `auto_driver_configuration`. Sending either together with `driver: "max"` returns a `400` error.
>
> **Rendering:** leave `render` unset. Each driver in the race applies its own rendering configuration, so both non-rendered and rendered results compete.
>
> **Example:**
>
> ```json theme={"system"}
> "driver": "max"
> ```

> [accordion] request\_timeout
>
> **request\_timeout** `number`
>
> Maximum time in milliseconds to wait for the whole request. The timeout caps the race as a whole, not each driver. If no driver succeeds before the deadline, the request fails.
>
> **Example:**
>
> ```json theme={"system"}
> "request_timeout": 30000
> ```

## Max vs. auto

Both options let Nimble pick the driver for you. They optimize for different things.

| | `render: "auto"` | `driver: "max"` |
| - | - | - |
| **How** | One driver at a time | All drivers at once |
| **Best for** | Lowest cost | Fastest result |
| **Latency** | Grows per escalation | Quickest driver |
| **Billing** | Driver that succeeded | \$2.50 / 1K URLs |
| **Tuning** | `auto_driver_configuration` | None |

Pick `render: "auto"` for high-volume jobs where cost matters. Pick `driver: "max"` for real-time workloads, agent tool calls, and sites that block cheaper drivers.

> [!WARNING]
>
> `max` runs every driver for every request, so it costs more per URL than a single driver. Do not use it for large crawls of simple static pages. Use `vx6` or `render: "auto"` instead.

## Usage

### Fetch a protected page as fast as possible

Let stealth and rendering drivers race against plain HTTP. The response comes from whichever gets through first.

```python Python theme={"system"}
from nimble_python import Nimble

nimble = Nimble(api_key="YOUR-API-KEY")

result = nimble.extract.run(
    url="https://www.protected-site.com/product/123",
    driver="max",
    formats=["markdown"]
)

print(result.data.markdown)
```

```typescript TypeScript theme={"system"}
import Nimble from "@nimble-way/nimble-js";

const nimble = new Nimble({ apiKey: "YOUR-API-KEY" });

const result = await nimble.extract.run({
  url: "https://www.protected-site.com/product/123",
  driver: "max",
  formats: ["markdown"],
});

console.log(result.data?.markdown);
```

```bash cURL theme={"system"}
curl -X POST 'https://sdk.nimbleway.com/v2/extract' \
--header 'Authorization: Bearer <YOUR-API-KEY>' \
--header 'Content-Type: application/json' \
--data-raw '{
    "url": "https://www.protected-site.com/product/123",
    "driver": "max",
    "formats": ["markdown"]
}'
```

```bash CLI theme={"system"}
nimble extract run \
  --url "https://www.protected-site.com/product/123" \
  --driver max \
  --format markdown
```

### Cap the wait time

Combine `max` with `request_timeout` to fail fast when no driver gets through.

```python Python theme={"system"}
from nimble_python import Nimble

nimble = Nimble(api_key="YOUR-API-KEY")

result = nimble.extract.run(
    url="https://www.example.com",
    driver="max",
    request_timeout=30000
)

print(result.status)
```

```typescript TypeScript theme={"system"}
import Nimble from "@nimble-way/nimble-js";

const nimble = new Nimble({ apiKey: "YOUR-API-KEY" });

const result = await nimble.extract.run({
  url: "https://www.example.com",
  driver: "max",
  request_timeout: 30000,
});

console.log(result.status);
```

```bash cURL theme={"system"}
curl -X POST 'https://sdk.nimbleway.com/v2/extract' \
--header 'Authorization: Bearer <YOUR-API-KEY>' \
--header 'Content-Type: application/json' \
--data-raw '{
    "url": "https://www.example.com",
    "driver": "max",
    "request_timeout": 30000
}'
```

```bash CLI theme={"system"}
nimble extract run \
  --url "https://www.example.com" \
  --driver max \
  --request-timeout 30000
```

## Related

> [card] [JS Rendering](https://docs.nimbleway.com/nimble-sdk/web-tools/extract/features/js-rendering.md)
>
> Automatic driver selection with `render: "auto"`

> [card] [Stealth Mode](https://docs.nimbleway.com/nimble-sdk/web-tools/extract/features/stealth-mode.md)
>
> Pick a single stealth driver by hand

> [card] [Advanced Options](https://docs.nimbleway.com/nimble-sdk/web-tools/extract/features/advanced-options.md)
>
> Timeouts, sessions, and device emulation

> [card] [Pricing](https://docs.nimbleway.com/nimble-sdk/admin/pricing.md)
>
> Extract pricing, including the max driver


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.