# Firecrawl API Limits and Credits for Developers

By Petra Vlk · 2026-11-19 · Source: https://www.activepieces.com/blog/firecrawl-api-limits-and-credits-for-developers

---
<aside class="tldr"><p class="tldr-label">Summary</p><p>Firecrawl's free tier allows 1,000 monthly credits and 2 concurrent requests, but crawls expand to multiple pages and drain allowances quickly.</p><ul><li>10,000-page crawls exceed Free plan's 1,000 credits regardless of per-page cost structure.</li><li>/crawl endpoint allows 2 requests per minute on Free, 100 on Standard tier.</li><li>Scale tier offers 100 concurrent requests compared to Free tier's 2 concurrent limit.</li></ul></aside>

The [Firecrawl](https://www.firecrawl.dev/pricing) API is a set of HTTP endpoints that turn web pages into clean, LLM-ready data, and because any HTTP client can call it, you can just as easily trigger it from a workflow tool like [Activepieces](https://www.activepieces.com) as from your own code, and every call spends credits from the account that owns your key.

The calls are easy. The credit balance and concurrency allowance are what decide whether a job finishes.

## Firecrawl API Access, Endpoints and Getting a Key

### What the API lets you do

You can fetch one page as markdown or structured data, walk an entire site, or list the URLs a site exposes. You can also search the web and get page content back, or pull fields out of pages against a schema.

You think you made one call, and you end up with an empty balance and a half-finished result. That is the crawl. **A single page costs very little**, but a crawl fans out into many pages you didn't individually request, and each page spends credits.

<blockquote class="pull"><p>You think you made one call, and you end up with an empty balance and a half-finished result.</p></blockquote>

### Endpoints compared: scrape, crawl, map, search, extract

Read the async column first: an async endpoint returns an identifier, not data, and a script that treats it as the result will quietly store nothing.

The table shows what each endpoint is for and whether it answers immediately or hands you a job to poll.

| Endpoint | What it is for | Async |
|---|---|---|
| scrape | One URL in, one page of content out | No, returns in the response |
| crawl | Following links across a site and returning every page found | Yes, returns a job to check |
| map | Listing the URLs on a site without fetching their content | No, returns in the response |
| search | Running a web query and returning results | No, returns in the response |
| extract | Pulling structured fields from pages using a prompt or schema | Yes, returns a job to check |

When credits or concurrency run out, a job can be accepted, run partway and stop, and that happens on the two async endpoints, crawl and extract. Run map first when you're unsure how large a site is.

You get a key from a Firecrawl account, created in the dashboard, and send it as a bearer token with each request.

Which endpoints, credit allowances and concurrency limits your plan includes is set on the pricing page and in the docs, and both change. Read them on the day you build, not from this article.

## Authentication and a Minimal Working Request

Send your API key as a Bearer token in the Authorization header, because Firecrawl authenticates every call that way. One leaked or missing key is the difference between a working job and a wall of rejected requests.

![Request card with Bearer key in Authorization header heading to an API server](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/775a08b4-ed7b-44a7-9b1a-1f08f2ce037c/firecrawl-api-limits-and-credits-for-developers-42731ac2.webp)

Check the exact header format and endpoint path in the current docs before you copy anything below.

Once a key is pasted into source code, it is hard to undo, so the order of the five steps below matters. They take you from nothing to one confirmed scrape.

1. Create the key in the Firecrawl dashboard.
2. Store it in an environment variable, never in the script or the repository.
3. Send it as the `Authorization: Bearer` header on every request.
4. Scrape one URL.
5. Check the `success` flag in the response before you use anything else in it.

If someone else holds the key, they can spend your credits, and the dashboard can't tell your job from theirs. That is why step two is the one that protects them.

Set the key and the scrape endpoint from the docs as environment variables, then call it:

```bash
export FIRECRAWL_API_KEY="your key from the dashboard"

curl -X POST "$FIRECRAWL_SCRAPE_URL" \
 -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
 -H "Content-Type: application/json" \
 -d '{"url": "https://example.com"}'
```

Look for `"success": true` alongside the page content in a good response:

- Test that flag in your code rather than assuming a reply means success
- A failed call can still return a body
- A pipeline that skips the check will happily process an error message as if it were a page

### Making the request with the Firecrawl Python SDK

The SDK reads the same key and builds the header for you:

```python
import os
from firecrawl import Firecrawl

app = Firecrawl(api_key=os.environ)
result = app.scrape("https://example.com", formats=["markdown"])
print(result)
```

Confirm method names and return shapes against the docs for the version you install, because they change between SDK releases. The point is the same as with curl: one URL, one request, one result you inspect before scaling up.

![Activepieces workflow builder showing a Send HTTP request step configured with Google Search RapidAPI credentials.](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/da977bec-9b3b-44ea-89dc-d64f009a35fe/opus-clip-integration-how-to-set-it-up-2026-guid-8ea5333c.webp)

Once this single call works, the next thing to learn is what it cost and how many of them you can run at once.

## Credit Pricing and Rate Limits by Plan

You are billed in credits and capped per plan:

- Free gets 1,000 credits a month: - Hobby gets 5,000 credits a month
- A 10,000-page job fails on both: before concurrency even matters

### Credits per page by endpoint

I'm not quoting a per-page credit rate for each endpoint here, because the figures I can confirm are plan limits, not rates.

Costly options such as JSON extraction raise the per-page rate, so read the current rate on the day you build, then multiply by your page count before you start.

**10,000 pages at even one credit each already exceeds Free and Hobby, and that multiplication is the whole test.**

Set your page count against the monthly credits on [Firecrawl's pricing page](https://www.firecrawl.dev/pricing): 1,000 on Free, 5,000 on Hobby, 100,000 on Standard, 500,000 on Growth and 1,000,000 on Scale.

![Monthly Firecrawl credits per plan against a big job](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/83fbfb81-1f19-4b78-ba68-ff73186d9f51/firecrawl-api-limits-and-credits-for-developers-8e86db46.svg "Source: Firecrawl")

Standard covers 10,000 pages only if each costs under ten credits. Past that, you're rationing. Prices are on the same page and change, so check them there.

### Rate limits and concurrency by plan

Take one thing from the table below: /crawl is the endpoint that throttles first. Concurrency and per-minute limits rise together but at different speeds (checked 19 Nov 2026).

| Plan | Monthly credits | Concurrent requests | /scrape per min | /crawl per min | /search per min | /map per min |
|---|---|---|---|---|---|---|
| Free | 1,000 | 2 | 10 | 2 | 10 | 10 |
| Hobby | 5,000 | 5 | 100 | 15 | 50 | 100 |
| Standard | 100,000 | 25 | 500 | 100 | 100 | 500 |
| Growth | 500,000 | 50 | 5,000 | 250 | 2,500 | 5,000 |
| Scale | 1,000,000 | 100 | not published | not published | not published | not published |

The per-minute figures come from [Firecrawl's rate-limits page](https://docs.firecrawl.dev/rate-limits), which lists four values per endpoint. I have read them lowest to highest across the first four plans, and that page doesn't give a Scale row here, which means Scale's information is not provided in that view.

![Firecrawl request limits per minute, by endpoint and plan](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/1ccd9bda-ef9e-472e-8543-cb0a22a95ac1/firecrawl-api-limits-and-credits-for-developers-489e974c.svg "Source: Firecrawl")

Concurrency comes from the pricing page.

You can't process requests in parallel or trigger frequent crawls on Free, which allows 2 concurrent requests and 1 /crawl per minute, so batch operations will take as many minutes as they have crawls.

![Concurrent requests Firecrawl allows on each plan](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/b878141d-2a47-495f-9673-f16a9b43e2ad/firecrawl-api-limits-and-credits-for-developers-330e8905.svg "Source: Firecrawl")

The API refuses a crawl job started a second time inside that minute, however good your code is.

At 100 concurrent requests, **Scale runs fifty times Free's**, but only if your credits last long enough to use them, which means your budget becomes the practical constraint rather than throughput capacity.

Your real ceiling is whichever comes first: the 100 limit or your credit balance.

Check each cell against the docs before you commit a job to it.

If the job is a scheduled scrape that sends results to a sheet, CRM or database, the Activepieces Firecrawl integration suits it.

It calls the same endpoints with the same API key, and the retry and the missing-pages report become steps in a flow instead of code you maintain.

The run is the meter on Activepieces: a ten-step flow with the credit check, retry and missing-pages report costs 1 credit, exactly what a two-step flow costs, while Zapier's pricing page counts per task and Make's per module, so each guardrail you add there raises the bill.

![A workflow builder showing a Skyvern step selected with its configuration panel open on the right, displaying API Key and…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/f8e7c6dd-e9bb-4aff-a41a-53393d8279d8/applied-epic-ai-integration-a-2026-guide-for-age-a415e648.webp)

## How an overnight Firecrawl crawl exhausts credits

Not one line of code changed, and the crawl that passed a clean test at 18:00 was out of credits before morning.

None of this is measured.

The allowance line never moves; only the slope of usage does, and the slope is what you control.

`{{chart}}`

Read the marks left to right, because each one caused the next.

### 02:00: the first rate-limit response

At 18:00 the test ran small and sequential, and every request returned success. So the job got approved.

At 02:00 someone raised the number of parallel requests to finish sooner.

That ran into the plan's concurrency limit, and the API answered with a 429, the standard "too many requests" status. Your test never touched that limit, so it told you nothing about it.

Put a retry loop on top and it gets worse. Each retry is another request against a limit already exceeded, and on any request that is accepted before the failure, you may be spending credits on pages you'll fetch again.

![Activepieces workflow builder showing a Skyvern agent task step with API configuration fields and failure handling options.](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/e773f985-47ff-4e08-b329-e17a067db6e5/activepieces-vs-temporal-for-workflow-automation-4b459e5d.webp)

### 03:30: credits run out mid-crawl

Because the scale-up also steepened the usage line, credits drained faster than the plan was sized for, and at 03:30 the allowance ran out with the crawl unfinished.

Past that point the errors are about billing, not speed, and no amount of waiting or backoff fixes them. The job stalls until the allowance is topped up or the plan period resets.

### Recovering a partial Firecrawl crawl after failures

At 08:00 you have a **partial dataset and a log full of failures**.

The dataset is only usable if the job recorded which URLs completed. Without that record, you can't tell finished pages from missing ones, and resuming means paying to fetch some of them twice.

To count what happened, take the pages fetched and multiply by the per-page credit rate in the docs that day. Do the same for the pages you meant to fetch.

The difference between that estimate and the allowance is the check that should have run before 18:00, not after 08:00.

## Catching Firecrawl errors with guardrails

By the time a check runs after the failure, it is a log entry. Firecrawl's errors fall into five rows, each of which a guardrail written in advance would have caught.

The table shows each status as the docs describe it, so you can match a failed job to its cause before you touch the code.

| Status | Docs-backed cause | Fix | Docs link |
|---|---|---|---|
| 401 | The API key is missing, malformed or revoked | Send a valid key in the authorization header; reissue it if revoked | [docs.firecrawl.dev](https://docs.firecrawl.dev) |
| 402 | The account has no credits left for the request | Top up or change plan, then rerun only the unfinished work | [docs.firecrawl.dev](https://docs.firecrawl.dev) |
| 429 | Requests exceeded the rate or concurrency limit for your plan | Back off and retry; lower parallel jobs | [docs.firecrawl.dev/rate-limits](https://docs.firecrawl.dev/rate-limits) |
| Timeout | A page did not finish loading or scraping in the allowed time | Raise the timeout parameter for slow pages, or skip and log them | [docs.firecrawl.dev](https://docs.firecrawl.dev) |
| Partial crawl | The crawl stopped at the limit you set, or credits ran out mid-job | Set the page limit deliberately; resume from the failed pages | [docs.firecrawl.dev](https://docs.firecrawl.dev) |

Because every row ends in work that didn't happen, read the plan's current limits on the day you build and treat none of the above as fixed.

If you get a 401, the key is wrong, and a retry won't change that. A 402 means the key is fine and the credits are gone.

Treat them differently: the first is a configuration fault, the second is the overnight failure the estimate was meant to prevent.

When a 429 arrives, it is the plan's rate or concurrency limit speaking. Retrying immediately and in parallel makes the next refusal more likely. Wait, retry, and wait longer each time.

Neither a timeout nor a partial crawl announces itself. Each leaves you with a result that looks complete and isn't: a timeout hits one page, a partial crawl the whole job. So the job must say which pages are missing.

![A tidy stack of pages in a tray whose top sheet looks perfect, but the stack beneath is hollow, a cardboard cake slice with…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/316ba466-efc8-4d46-ac39-15ea0dd5eb1c/firecrawl-api-limits-and-credits-for-developers-da85f5f1.webp)

After the incident, four rules were added:

1. Set a page limit on every crawl, so one start URL can't spend the month.
2. Retry 429s with exponential backoff, and cap the number of retries.
3. Check remaining credits against the job's estimate before it starts.
4. **Write every failed page to a log**, so a rerun covers only the gaps.

## Calling Firecrawl Without Code Using Activepieces

Everything above assumed code, but the same job can run as a flow. The sections below cover when that fits and how to build it.

### When a no-code workflow fits

Pick the flow when the job is a timer, a list of URLs and a destination. Your credits and concurrency limits are the same either way, because the integration sends your key to the same API. It doesn't raise a ceiling.

![Activepieces workflow builder displaying an AI blog writing automation with OpenAI and WordPress integration steps.](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/ca000698-c716-45d3-916f-88df50a3761a/spotify-automation-ways-to-set-it-up-2026-guide-fa565726.webp)

What the integration changes is where the safeguards live.

A credit check before the scrape and a retry after a failed call are each a visible step. So is a message listing the pages that didn't come back, and a colleague can open and read any of them without finding your repository.

Keep the code when you need to control concurrency tightly, or when a crawl is large enough that you must track partial progress yourself. Keep it too when the job sits inside a service you already deploy and test.

A flow shows you a run, but it won't enforce your concurrency ceiling for you. Read the current limits in the Firecrawl docs the day you build, and set the flow's schedule to respect them.

### Building a scrape-and-store workflow

In the screenshot below, four steps run top to bottom, making delays in any early step cascade through to the final one, so your deadline is set by the first step.

![Four conveyor belts in a descending staircase, each feeding the next, with a single small crate stuck at the first belt…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/43db85aa-2d09-462e-9cee-d42d41b73b2c/firecrawl-api-limits-and-credits-for-developers-58d3d6f0.webp)

It is an unrelated Activepieces flow, an "AI Blog Writer" that ends in a WordPress step, but it shows the mechanics you'll reuse.

The selected WordPress step fills its Title and Content fields by pointing at the output of the earlier Open AI steps. That's the whole technique: each step's fields reference the steps above it, so you can put a check between any two of them.

In your own flow, the order is:

1. A schedule trigger starts the run.
2. A Firecrawl step, authenticated with a connection holding your API key, scrapes the page.
3. A check on that step's output sends failed or empty results to a retry or to an alert, rather than on to storage.
4. A storage step writes the content wherever you keep it, and a final message names every URL that failed.

Without the fourth step, a partial run passes as a complete one. Test the flow against a handful of URLs first, then read the run history for any step that failed quietly.

## Frequently asked questions

Once a job has run, the history tells you what it did; these answers cover what it cost and what to confirm before the next one. Four questions the body leaves open are answered below, each checked against the docs on 19 Nov 2026.

- Do unused credits roll over? Read the billing section of the [Firecrawl docs](https://docs.firecrawl.dev) before you size a plan, because a plan sized on a rollover you assumed will run dry mid-job (checked 19 Nov 2026).
- Are failed pages billed? The docs' billing notes say what counts as a charged request, so read them before you retry in a loop (checked 19 Nov 2026).
- How do I check remaining credits? The dashboard and the API reference both cover usage, so add a check before any large crawl (checked 19 Nov 2026, [docs](https://docs.firecrawl.dev)).
- Where are the limits listed? The rate-limit and plan pages in the [docs](https://docs.firecrawl.dev) hold the current figures, so copy none from an article, this one included (checked 19 Nov 2026).

The sections below cover the questions that come up before any of that.

### Free tier and self-hosting

Is the Firecrawl API free to use? There's a free tier, but it's an allowance, not an open door.

Once its credits or concurrency are spent, requests stop or queue, so treat it as a place to test against a handful of URLs, not to run a production job. Check the pricing page for what it includes today.

Does Firecrawl have a self-hosted option? Yes, the project is open source and can be run on your own infrastructure.

Self-hosting removes the credit meter but replaces it with your own servers, proxies and upkeep. The docs say which hosted features the self-hosted version lacks, so read that list before you commit.

### Credits, SDKs and alternatives

Do unused credits roll over? Don't assume so. The bullet above points to where the docs state the rule. Until you have read it, plan as though each period's allowance must cover that period's jobs.

Which Python SDK should I install? Use the official SDK from Firecrawl's own docs, not a third-party wrapper. Official packages follow the API's changes; wrappers can lag behind a renamed endpoint or a changed response.

What are the main alternatives to the Firecrawl API? Apify, ScrapingBee and Jina Reader are hosted options, and Crawl4AI is an open-source library you run yourself. Each meters usage differently, so compare how they charge for failed or retried pages before you compare features.

## Related reading

- [Firecrawl Pricing 2026: Plans, Credits and Real Costs](https://www.activepieces.com/blog/firecrawl-pricing-2026-plans-credits-and-real-costs)
- [Google Docs API Rate Limits for Developers (2026)](https://www.activepieces.com/blog/google-docs-api-rate-limits-for-developers-2026)
- [Turn Web Data Into Powerful Workflows: Firecrawl 🤝Activepieces](https://www.activepieces.com/blog/turn-web-data-into-powerful-workflows-firecrawl-activepieces)

## References

- [Firecrawl](https://docs.firecrawl.dev/rate-limits)
- [Firecrawl](https://www.firecrawl.dev/pricing)
