Pricing
Monthly plans whose fee becomes usage balance, per-request rates, and how to top up, billed in USD.
Each plan's monthly fee is added to your balance as usage credit, and requests draw that balance down at a fixed USD rate per request. The rate depends on the fetch method the API selects and the proxy class the target site needs, and it is lower on higher-tier plans.
A request is billed when String returns the destination's response, whatever status the destination sent: a destination
404 comes back inside a 200 and is billed. Failed requests are not billed, with two exceptions:
- A
502that carriesx-billed-request-typeis billed at the type that header names. A destination certificate that can't be verified can return one. - A request with custom
headersthat the destination blocks is billed.
A request with actions or screenshot is billed once url
loads, even if a later action fails or the request ends on a page that errors or that the destination blocks. It isn't
billed if url doesn't load, the destination blocks it, or the request returns an error status. A billed response
carries x-billed-request-type.
Plans
| Plan | Monthly fee |
|---|---|
| Starter | $19.00 |
| Growth | $99.00 |
| Scale | $499.00 |
| Volume | $999.00 |
Balance and top-ups
The full monthly fee goes onto your balance each billing period. Unused balance rolls over and does not expire, and it stays usable after you cancel. There is no separate credit pack: a plan is how you buy balance.
On a plan, add funds or turn on auto top-up under Usage & Plans. Each top-up adds
a fixed amount set by your plan. Auto top-up adds it when your balance runs low, so requests don't stop at 402, and
you can set a spend limit per billing period.
Trying the API
A new organization starts with a $5.00 balance and one API key, so you can try the API before choosing a plan. Without a plan, usage is billed at Starter rates: on a standard proxy, $0.25 per 1,000 request-based fetches and $1.20 per 1,000 browser-based fetches, and $1.20 per 1,000 searches. $5.00 covers 20,000 request-based fetches or about 4,100 browser-based fetches on a standard proxy, or about 4,100 searches. The starting balance is granted once per person; a repeat signup starts with no balance.
String has no separate sandbox or test environment: requests you make while trying the API are billed from your balance
under the same rules as any other request. When the balance can't cover a request, the API returns
402. To keep going, choose a plan under
Usage & Plans.
Throughput
Every plan can have up to 10,000 fetches and 5,000 browser sessions in flight at once. The request rate, the number of requests admitted per second for your organization, is 15 on Free and Starter, 30 on Growth, 60 on Scale and 90 on Volume. Until your organization subscribes to a plan, it is on the Free rate.
| Limit | Free | Starter | Growth | Scale | Volume | Enterprise |
|---|---|---|---|---|---|---|
| Concurrent fetches | 10,000 | 10,000 | 10,000 | 10,000 | 10,000 | 10,000 |
| Concurrent browsers | 5,000 | 5,000 | 5,000 | 5,000 | 5,000 | 5,000 |
| Request rate | 15 / sec | 15 / sec | 30 / sec | 60+ / sec | 90+ / sec | Custom |
See rate limits for how the rate is measured and the 429 contract. Need a higher
rate? Contact [email protected].
Enterprise accounts can also read a rendered page's cookies with
captureCookies.
Usage — per 1,000 requests
| Fetch path | Proxy class | Starter | Growth | Scale | Volume |
|---|---|---|---|---|---|
| Request-based fetch | Standard proxy | $0.25 | $0.16 | $0.13 | $0.11 |
| Request-based fetch | Premium proxy | $2.40 | $0.90 | $0.55 | $0.45 |
| Browser-based fetch | Standard proxy | $1.20 | $0.80 | $0.55 | $0.50 |
| Browser-based fetch | Premium proxy | $4.80 | $3.25 | $2.60 | $2.20 |
AI structured extraction adds a dynamic fee
Requests that use jsonSchema add an extraction fee on top of the per-request
rate. It's metered per request and scales with the size of the page and the schema you request. The fee applies
whenever extraction runs, including requests that fall back
because the result didn't satisfy your schema. It isn't charged when extraction never ran, such as a page over the
size ceiling.
Search
Search has its own rate, separate from the fetch rates above:
| Usage | Starter | Growth | Scale | Volume |
|---|---|---|---|---|
| Per 1,000 searches | $1.20 | $0.70 | $0.50 | $0.45 |
A request with "aiOverview": true, which fills Google's streamed AI Overview with a second fetch, costs 2x a normal
search.
Browser sessions
Remote CDP WebSocket sessions are billed by resource usage instead of the per-request table above: bandwidth transferred
and connection time are summed per session and charged when the session ends. These rates are the same on every plan,
and each session is metered on its own — usage is not batched across sessions. The bandwidth rate depends on the
session's proxy tier — premium (residential) is the default;
standard (datacenter) is selected with ?proxy=standard on the connect URL. A /fetch with
actions or screenshot isn't billed this way: it is billed
per request at a browser-based fetch rate from the usage table.
| Browser session metric | Rate |
|---|---|
Bandwidth transferred — premium proxy (default) | $10.00 / GB |
Bandwidth transferred — standard proxy | $5.00 / GB |
| Session duration (either tier) | $0.12 / hr |
Composer builds
Each Composer build is paid from the same prepaid balance as your requests.
- A build is priced by the work that build itself did, plus the web requests it made at your organization's own rates from the tables above.
- Time a build spends waiting for you, at a question, an approval or a publish review, costs nothing.
- There is no estimate before a build starts.
- A build stops and asks you before it goes past $15.
- A build that fails because of a problem on our side is not charged. If a charge looks wrong, flag it from the build.
Sitemap
Each sitemap crawl is priced per page at the rate in its quote. The quoted cost is held when
you approve and settled against the pages actually crawled when the job finishes, and a crawl never costs more than its
budgetUsd.
Site integrations
Most site integration calls cost exactly what their requests cost. Each request an action makes goes through
/v1/fetch with your key and is billed at its own rate on your plan, as if you had sent it yourself. The action adds
no charge of its own. Failed requests follow the same rules as any other request, set out at the top of this page.
Per-row actions
Some actions are priced by the rows they return, and their page in the site integrations docs says so. The Reddit actions cost $1 per 1,000 rows, and each post and each comment counts as one row. A per-row call is charged once at the end, for the rows it returned. The requests it makes along the way are included, so they cost nothing on their own, and a call that returns no rows costs nothing.
What a call cost
The requests array in the response lists every billed request, with the rate it was billed
at in requestType:
"requests": [
{ "url": "https://…yelp.com/…", "requestType": "request_standard", "requestId": "d2d57cbf-…" },
{ "url": "https://…yelp.com/…", "requestType": "request_standard", "requestId": "e84222ff-…" }
],
"billing": { "mode": "passthrough", "calls": 1, "rows": 1 }This call made two requests at the request_standard rate, so it cost two request-based, standard-proxy requests from
the usage table.
The billing block says how the call itself was charged:
modeispassthrough: the requests are the whole charge. A per-row action reportsperRow, with its price per row inusd.callsis1for a call that returned rows or found nothing, and0for one that failed outright.rowsis the number of rows indata. For a per-row action it is the rows charged, so a Reddit post with 200 comments counts as 201.
When a call stops on a 402 or 429 part way through, the requests it had already made are billed even though no
envelope comes back.
Estimating a call before you make it
Each action declares a request band: how many requests it makes per unit of work. The band is on every action in
the catalog, and in the manifest as requests:
"requests": { "min": 1, "max": 2, "per": "item" }per | One unit is | Example |
|---|---|---|
item | Each entry in items. | Yelp business: 1–2 requests per business. |
page | Each page of results you ask for, such as with pages. | Yelp search: 1–2 requests per page of 10 results. |
batch | Each group of up to size entries in items, sent together. | { "min": 1, "max": 1, "per": "batch", "size": 25 }: 1 request per 25 entries. |
run | The whole call, whatever the input. | { "min": 1, "max": 3, "per": "run" }: 1–3 requests per call. |
setup, when present, is the most requests a call makes once on top of the band, such as resolving a business alias
before reading its reviews. Yelp reviews is { "min": 1, "max": 1, "per": "page", "setup": 1 }: one request per page
of reviews, plus up to one per call.
So a Yelp business call with 100 entries in items makes between 100 and 200 requests. Which rate each request is
billed at depends on the site; the requestType values in a test call show you.
Listed prices
Each action in the catalog also shows how it's billed, and the manifest carries it as billing. Every action is
listed as passthrough: billed per request at your plan's rates, with no charge for the action itself. Estimate
costs from the request band and the requestType rates, and read billing.mode in the response to see how a call was
actually charged.