# Pricing (/docs/pricing)

Bowmark charges in **US dollars for the resources a call actually uses**: proxy
bandwidth, page-rendering time, captcha solves, and paid data APIs. Reading the library
(`get_library`) and running your script's own code are free.

## How charging works

* **$10 of usage is free every month**, on every account, with or without a card.
* **Only calls that work are charged, except for rendering time.** A call that failed
  because of Bowmark or the site (a block, a failed solve, a timeout) costs nothing for
  its bandwidth, solves and API requests. Rendering time is always charged, whatever the
  call did, because the page was held open either way. A call that failed because of
  the arguments your script passed is charged in full, since the resources were used.
* **Your usage and charges are on the [billing dashboard](https://bowmark.ai/dashboard/billing),
  and at `GET /v1/usage` for an API-key-only caller with no dashboard login.**
  A run's result does not carry its price, there are no prices in `get_library`, and
  there is no quote before a run.
* **A call that totals under $0.001 is not charged.**
* **Past the free $10, you need a card on file.** Without one, calls stop until the
  month resets. With one, usage above $10 is billed as you go: your card is charged
  each time $20 accrues, and the rest on your monthly invoice.
* **Every account has a monthly spend cap**, $50 to start. Calls stop when you reach it,
  and you are emailed at 80% and 100%. Change it on the
  [billing page](https://bowmark.ai/dashboard/billing).
* **A declined card stops calls at once.** Update the card and the balance is charged
  and calls resume.

## Rates

### Proxy bandwidth and exits

The residential or datacenter address a request leaves from. Direct requests have no charge.

| Resource                     | Price   | Unit        |
| ---------------------------- | ------- | ----------- |
| `proxy.residential-rotating` | $11.02  | per GiB     |
| `proxy.static-residential`   | $0.0001 | per request |
| `proxy.us-datacenter`        | $1.00   | per GiB     |
| `proxy.mobile`               | $18.00  | per GiB     |

### Page rendering

Charged for the time a fully rendered page is held open for a call, from start to finish, including a wait for you to sign in. Rendering time is charged even when the call fails, because the page was held open either way.

**`bowmark.read.page(url)` reads any page without a dedicated provider.** It starts with a fast fetch, charged only for proxy bandwidth if you use one; if the page needs rendering to read the data, it escalates to a browser render at the rate above. A simple page read costs nothing beyond proxy bandwidth. A read that needs rendering typically takes 30-90 seconds and costs roughly $0.002-$0.006 for rendering on top of proxy costs. Check your [billing dashboard](https://bowmark.ai/dashboard/billing) for the actual cost of your reads.

| Resource           | Price  | Unit       |
| ------------------ | ------ | ---------- |
| `browser.headless` | $0.004 | per minute |
| `browser.headed`   | $0.008 | per minute |

### Extended page rendering

When a page needs more work than a standard render to answer a call, that extra rendering is metered on the call and itemized on your [billing dashboard](https://bowmark.ai/dashboard/billing) as `browser.extended`.

### Captcha solves

One charge per solution returned.

| Resource               | Price   | Unit      |
| ---------------------- | ------- | --------- |
| `captcha.turnstile`    | $0.0024 | per solve |
| `captcha.cloudflare`   | $0.0024 | per solve |
| `captcha.recaptcha-v2` | $0.0016 | per solve |
| `captcha.recaptcha-v3` | $0.002  | per solve |
| `captcha.datadome`     | $0.005  | per solve |
| `captcha.aws-waf`      | $0.004  | per solve |
| `captcha.hcaptcha`     | $0.0024 | per solve |
| `captcha.image`        | $0.002  | per solve |

### Bot-defense sensor payloads

One charge per payload generated.

| Resource           | Price   | Unit        |
| ------------------ | ------- | ----------- |
| `sensor.akamai`    | $0.0066 | per request |
| `sensor.incapsula` | $0.0066 | per request |
| `sensor.other`     | $0.0066 | per request |

### Dedicated egress IPs

A leased IP (`bowmark.egress.lease`) is a dedicated exit ordered just for you, charged for the whole term up front — never per byte or per request. The exact charge is itemized on your [billing dashboard](https://bowmark.ai/dashboard/billing) as `proxy.lease.isp` when you place it (static ISP is the only kind sold today; `proxy.lease.datacenter` is priced and reserved for later). Call `bowmark.egress.quote` first to see the price and the term before buying; there is no refund or proration once ordered.

### Hosted browser agents

A browser agent (`bowmark.browser_agent`) is metered on the run: the model turns it takes and the browser it drives. There is no flat per-run price, so each run's charge is itemized on your [billing dashboard](https://bowmark.ai/dashboard/billing) as `browser_agent.vendor`. Send your own key as the `x-bowmark-vendor-key-browser_use` header and the run is free.

**Per-call pricing:** Each call has a ceiling of $25 USD (default budget: $2 per call). You can adjust this ceiling with the `maxCostUsd` parameter when starting a session.

**Estimating costs:** Each step the agent takes through your task incurs a model turn. A typical multi-step workflow (e.g., navigating a site, filling a form, extracting data) might take 15–30 turns depending on task complexity. Model turns cost roughly **$0.001–$0.01 per turn** depending on which model the agent uses, so a 20-step task typically costs $0.02–$0.20 for the model. On top of that, add the page-rendering time at the rates above ($0.004/min, or $0.008/min with a display). **Example:** a 20-step task taking 3 minutes of rendering time costs approximately $0.02–$0.20 for the model turns plus $0.012 for the rendering time, so **roughly $0.03–$0.21 total**. Your [billing dashboard](https://bowmark.ai/dashboard/billing) shows the itemized cost of every run under `browser_agent.vendor`, so you can refine your estimates based on measured runs.

### Delegated coding agents

A delegated agent (`bowmark.delegate`) is metered on two clocks: the machine it runs in, by the second for as long as the machine exists, and the model tokens the agent uses. Both are itemized on your [billing dashboard](https://bowmark.ai/dashboard/billing), as `delegate.sandbox` and `delegate.llm`.

**Spend ceiling:** every session has one, `maxCostUsd` (default $5, at most $50), and it counts both clocks in the dollars you are charged. When a session reaches it, the agent is stopped and reports what it has done so far.

**Stop what you start:** a machine is billed until you `stop` it, it reaches its `maxMinutes` (default 30, at most 55), or it has sat idle for 20 minutes after its last turn.

### AI text

One completion from `POST /v1/ai/text` is charged at the model's own token price for that one request, and itemized on your [billing dashboard](https://bowmark.ai/dashboard/billing) as `ai.text`. Short drafts on the default model cost a fraction of a cent.

### Image and video generation

An image or video from `bowmark.providers.higgsfield` is priced per generation, and the price depends on the model — a single still and a long video are nowhere near each other. Only a generation that finishes is charged, and each one is itemized on your [billing dashboard](https://bowmark.ai/dashboard/billing) as `higgsfield.generation`. Send your own key as the `x-bowmark-vendor-key-higgsfield` header and the generation is free.

### File storage

Files your runs save with `bowmark.files`, and files you upload, are charged for the space they take while you keep them, added up daily. Deleting a file stops its charge. Downloads and links are free.

| Resource        | Price | Unit                     |
| --------------- | ----- | ------------------------ |
| `storage.files` | $0.03 | per GiB kept for a month |

### Keeping saved logins alive

Bowmark checks each saved login on its keep-alive schedule (every 12 hours unless you change it) so it is still signed in when a run needs it. Each check that gets an answer from the site is charged for the resources it used, and never less than the minimum below. A check that fails on our side is free. Turn keep-alive off for a login, or delete it, to stop the checks.

| Resource                | Price  | Unit              |
| ----------------------- | ------ | ----------------- |
| `connection.keep_alive` | $0.001 | minimum per check |

### Paid data APIs on Bowmark's key

One charge per request. Send your own key as the `x-bowmark-vendor-key-<vendor>` header and that request is free.

| Resource     | Price  | Unit        |
| ------------ | ------ | ----------- |
| `api.serper` | $0.002 | per request |
| `api.hunter` | $0.20  | per request |
| `api.keepa`  | $0.004 | per request |