> ## Documentation Index
> Fetch the complete documentation index at: https://deepline.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Browserbase Fetch Page: Inputs, Cost & CLI Example

> Fetching a URL through Browserbase Fetch. Includes inputs, outputs, pricing notes, Deepline CLI examples, and GTM automation guidance.

## Run in Enrichment Spreadsheet

<Info>
  Use this function as a column step in `deepline enrich`.
</Info>

```bash theme={null}
deepline enrich --input leads.csv --output leads.enriched.csv --with 'result=browserbase_fetch_page:{"url":"{{url}}"}' --json
```

<Tip>
  Map payload values to spreadsheet columns with `{{column_name}}` placeholders.
</Tip>

## Input Schema

| Name                       | Type                            | Required | Default | Description                                                                                                                                                                               |
| -------------------------- | ------------------------------- | -------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payload.url`              | `string`                        | Yes      |         | The URL to fetch                                                                                                                                                                          |
| `payload.allowRedirects`   | `boolean`                       | No       | `false` | Whether to follow HTTP redirects                                                                                                                                                          |
| `payload.allowInsecureSsl` | `boolean`                       | No       | `false` | Whether to bypass TLS certificate verification                                                                                                                                            |
| `payload.proxies`          | `boolean`                       | No       | `false` | Whether to enable proxy support for the request                                                                                                                                           |
| `payload.format`           | `"raw" \| "json" \| "markdown"` | No       | `"raw"` | Output format for the response content. `raw` (default) returns the response body unchanged; `json` returns structured data (requires `schema`); `markdown` returns the page as markdown. |
| `payload.schema`           | `record`                        | No       |         | JSON Schema describing the desired structure of the response. Only used when `format` is `json`.                                                                                          |

### Allowed values

| Field            | Allowed values            |
| ---------------- | ------------------------- |
| `payload.format` | `raw`, `json`, `markdown` |

<details>
  <summary>Show raw input schema</summary>

  ### Input JSON Schema

  ```json theme={null}
  {
    "type": "object",
    "description": "Fetch a page and return its content, headers, and metadata.",
    "properties": {
      "url": {
        "type": "string",
        "description": "The URL to fetch",
        "format": "uri"
      },
      "allowRedirects": {
        "type": "boolean",
        "description": "Whether to follow HTTP redirects",
        "default": false
      },
      "allowInsecureSsl": {
        "type": "boolean",
        "description": "Whether to bypass TLS certificate verification",
        "default": false
      },
      "proxies": {
        "type": "boolean",
        "description": "Whether to enable proxy support for the request",
        "default": false
      },
      "format": {
        "description": "Output format for the response content. `raw` (default) returns the response body unchanged; `json` returns structured data (requires `schema`); `markdown` returns the page as markdown.",
        "default": "raw",
        "anyOf": [
          {
            "type": "string",
            "enum": [
              "raw"
            ]
          },
          {
            "type": "string",
            "enum": [
              "json"
            ]
          },
          {
            "type": "string",
            "enum": [
              "markdown"
            ]
          }
        ]
      },
      "schema": {
        "type": "object",
        "description": "JSON Schema describing the desired structure of the response. Only used when `format` is `json`.",
        "additionalProperties": {}
      }
    },
    "required": [
      "url"
    ],
    "additionalProperties": false
  }
  ```
</details>

## Output Schema

| Name          | Type     | Required | Default | Description                                    |
| ------------- | -------- | -------- | ------- | ---------------------------------------------- |
| `result.data` | `object` | Yes      |         | Provider response payload.                     |
| `result.meta` | `object` | No       |         | Additional response metadata (status, paging). |

<details>
  <summary>Show raw output schema</summary>

  ### Output JSON Schema

  ```json theme={null}
  {
    "type": "object",
    "description": "Standard tool result payload.",
    "properties": {
      "data": {
        "type": "object",
        "description": "Provider response payload.",
        "properties": {
          "id": {
            "type": "string",
            "description": "Unique identifier for the fetch request"
          },
          "statusCode": {
            "type": "integer",
            "description": "HTTP status code of the fetched response"
          },
          "headers": {
            "type": "object",
            "description": "Response headers as key-value pairs",
            "additionalProperties": {
              "type": "string"
            }
          },
          "content": {
            "description": "The response body content. A string for `raw` and `markdown` formats; a structured object for `json` format (the schema-extracted result).",
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "object",
                "additionalProperties": {}
              }
            ]
          },
          "contentType": {
            "type": "string",
            "description": "The MIME type of the response"
          },
          "encoding": {
            "type": "string",
            "description": "The character encoding of the response"
          }
        },
        "required": [
          "id",
          "statusCode",
          "headers",
          "content",
          "contentType",
          "encoding"
        ],
        "additionalProperties": false
      },
      "meta": {
        "type": "object",
        "description": "Additional response metadata (status, paging).",
        "additionalProperties": true
      }
    },
    "required": [
      "data"
    ],
    "additionalProperties": false
  }
  ```
</details>

## Advanced: Direct CLI

<Info>
  Use direct execution for single payload debugging.
</Info>

```bash theme={null}
deepline tools execute browserbase_fetch_page --payload '{
  "url": "string"
}' --json
```

### CLI flags

| Flag                        | Description                                         |
| --------------------------- | --------------------------------------------------- |
| `--json`                    | Print machine-readable output.                      |
| `--wait`                    | Wait for terminal provider status when supported.   |
| `--debug`                   | Enable wait mode with additional status/log output. |
| `--wait-timeout SECONDS`    | Max seconds to wait in wait mode.                   |
| `--poll-interval SECONDS`   | Polling interval in seconds during wait mode.       |
| `--timeout SECONDS`         | Request timeout in seconds.                         |
| `--connect-timeout SECONDS` | Connection timeout in seconds.                      |

## Provider API Context

<details>
  <summary>Show provider reference (optional)</summary>

  ````md theme={null}
  Sources:

  - https://docs.browserbase.com/reference/api/overview
  - https://docs.browserbase.com/reference/api/create-a-session
  - https://docs.browserbase.com/reference/api/fetch-a-page
  - https://docs.browserbase.com/reference/api/web-search
  - https://docs.browserbase.com/reference/api/run-an-agent
  - https://docs.browserbase.com/reference/api/invoke-a-function
  - https://docs.browserbase.com/account/billing/plans
  - https://www.browserbase.com/pricing

  Browserbase authenticates REST API requests with `X-BB-API-Key`.

  This connector uses Deepline-managed Browserbase credentials. Browserbase usage
  is billed to Deepline, and customers are charged Deepline credits. Never expose
  Browserbase provider spend directly to customers.

  Browserbase pricing is meter-based, not a single endpoint unit price:

  - browser sessions consume browser time and may also consume proxy bandwidth,
    model tokens, or other Browserbase platform meters depending on session/run
    configuration;
  - Search is metered by search calls after plan allocation;
  - Fetch is metered by fetch calls after plan allocation, with different
    behavior for raw, markdown, JSON extraction, and proxy usage;
  - Agents and Functions can consume browser time, model tokens, Search, Fetch,
    downloads, proxy bandwidth, and other Browserbase account meters.

  Pricing breakdown attached in Deepline cost metadata:

  - `browserbase_create_session`: paid provider usage. Uses Deepline's internal
    Browserbase browser-time model, billed with a one-minute minimum. If
    Browserbase proxies are enabled, Deepline also accounts for proxy bandwidth
    internally.
  - `browserbase_web_search`: paid provider usage. Uses Deepline's internal
    Browserbase Search request model.
  - `browserbase_fetch_page`: paid provider usage. Raw/markdown Fetch,
    proxy-backed Fetch, and JSON/schema extraction use Deepline's internal
    Browserbase request models.
  - `browserbase_run_agent`: disabled for customers, but retained as paid provider
    usage in the catalog. It must never become `no_bill` if re-enabled. Agent runs
    can consume browser time, model tokens, and proxies, and currently accept
    shared-project resources and sensitive data without tenant-scoped ownership
    or a zero-retention control.
  - `browserbase_invoke_function`: paid provider usage. Browserbase lists hosted
    functions as free, but an invoked function can run paid Browserbase workloads.
    Deepline attaches the minimum paid browser-time floor rather than marking the
    invocation endpoint `no_bill`.

  All other Browserbase endpoints in this connector are Deepline-team-only
  management/control/read operations with no published incremental API meter,
  disabled multipart upload operations, or live-deprecated operations. They remain
  explicit `no_bill` entries with free/read spend policy, but management APIs are
  internal-only and are not exposed as customer-facing Browserbase tools.

  The multipart upload endpoints for extensions, certificates, and session files
  are covered by the OpenAPI mapping but disabled in Deepline. They cannot be
  enabled until the executor supports multipart/form-data and Deepline can enforce
  tenant ownership for every created resource and every later resource reference.

  Public session creation rejects Browserbase project IDs, context IDs, extension
  IDs, certificate IDs, external proxy credentials, and arbitrary metadata. It
  also forces Browserbase session logging and recording off. Browserbase
  management/read APIs are internal-only at both discovery and execution time.

  `browserbase_update_context` is also covered but disabled. Live validation on
  July 7, 2026 returned Browserbase's context-upload deprecation 404 for this
  endpoint, so Deepline does not expose it as an executable tool until Browserbase
  re-enables or replaces API context updates.

  Live endpoint smoke test:

  ```bash
  ./scripts/with-env-local.sh env BROWSERBASE_LIVE_TEST=1 \
    bun run browserbase:live-smoke
  ```

  The smoke test requires the explicit opt-in because it creates one paid session
  and calls paid Search and Fetch. It covers every registered endpoint, uses
  temporary contexts and agents, releases the session, deletes temporary
  resources in a `finally` block, and never dispatches disabled uploads or Agent
  runs. Resource-specific internal endpoints are probed with synthetic IDs rather
  than reading or deleting existing project data.
  ````
</details>

## Cost

* Pricing model: `provider_usage` (provider usage).
* Estimated Deepline credits: `0.01` per pricing unit.
* Billing mode: `post_deduct`.