AgentQL pricing: what do I get in Starter vs Professional, and what are the overage costs per call/hour?

AgentQL keeps pricing simple: both the Starter and Professional plans give you the full developer toolset; what changes is how many API calls, remote browser hours, and concurrent sessions you get—and how much you pay when you go over those limits. Starter is tuned for individual developers and early projects, while Professional is built for teams running regular data workflows and web automation pipelines at higher scale.

Quick Answer: The Starter plan is $0/month with 50 free API calls per month, 10 hours of remote browser time, and 5 concurrent sessions, with overages at $0.02 per API call and $0.12 per remote browser hour. The Professional plan is $99/month with 10,000 included API calls, 500 remote browser hours, and 100 concurrent sessions, with overages at $0.015 per API call and $0.10 per remote browser hour—plus higher rate limits and priority support.

Why This Matters

If you’re wiring AgentQL into web agents, data pipelines, or grounding flows, you need to know two things up front:

How far you can go before hitting limits (calls/minute, hours, concurrency).
What it will cost when a proof of concept becomes a daily job that runs 24/7.

Picking the right plan—and understanding overages—lets you size your workloads confidently, avoid surprise bills, and decide when to step up from a personal dev setup to a team-grade pipeline.

Key Benefits:

Transparent scaling costs: Clear per‑call and per‑hour overages let you forecast spend as you add more pages, agents, or workflows.
Same developer experience on all plans: Both Starter and Professional include full access to AgentQL’s query language, SDKs, browser extension, and Playground.
Room to grow from POC to production: Start on free/low-cost tiers, then move to Professional when you need higher throughput and concurrency without rewriting your integration.

Core Concepts & Key Points

Concept	Definition	Why it's important
API call	A single request to AgentQL to analyze a page/document and return structured JSON.	Determines how many pages or documents you can process per month before overages apply.
Remote browser hour	One hour of usage for the hosted browser environment that powers Playwright-based extraction and automation.	Core for large crawls, dynamic sites, and agentic workflows that need real page interaction.
Concurrency & rate limits	Concurrency = how many remote browser sessions you can run at once; rate limit = API calls per minute.	Dictates how fast you can crawl websites or run parallel workflows without throttling.

Starter vs Professional: What You Actually Get

Here’s how the two main AgentQL plans compare when you’re building with Playwright, the SDKs, or the REST API.

Starter Plan (Best for Individual Builders & Early POCs)

Price: $0/month

Who it’s for: Developers building web agents and data workflows, early prototypes, and low-volume jobs.

Included in Starter:

50 API calls per month included
10 API calls per minute rate limit
10 hours of remote browser time included
5 concurrent remote browser sessions
Full access to developer tools:
- AgentQL query language & parser
- Python / JavaScript SDKs (Playwright-based)
- REST API (URL → JSON, no browser required)
- AgentQL IDE browser extension
- Playground for testing queries
Community and email support

Starter overage pricing:

$0.02 per API call after the included 50 calls
$0.12 per remote browser hour after the included 10 hours

This is ideal if you:

Are wiring AgentQL into a single web agent or internal script.
Run occasional scrapes or grounding workflows (e.g., nightly or ad‑hoc jobs).
Want full tooling access without committing to a paid subscription.

Professional Plan (Best for Teams & Regular Pipelines)

Price: $99/month

Who it’s for: Teams running regular data workflows and web automation pipelines where consistent throughput matters.

Included in Professional:

10,000 API calls per month included
50 API calls per minute rate limit
500 hours of remote browser time included
100 concurrent remote browser sessions
Full access to developer tools:
- Same query language, SDKs, REST API, extension, and Playground as Starter
Priority email support + community support

Professional overage pricing:

$0.015 per API call after the included 10,000 calls
$0.10 per remote browser hour after the included 500 hours

Professional makes sense when you:

Run production pipelines that hit thousands of pages per month.
Need higher concurrency for faster crawls or multiple agents running in parallel.
Want priority support and predictable scaling costs as your workloads grow.

Free Trial vs Starter

AgentQL also offers a free trial with:

300 free API calls
10 API calls per minute
1 hour of remote browser
1 concurrent remote browser session
Full access to developer tools + community/email support

The trial is a short, intensive way to test AgentQL on your real sites before you settle into Starter or Professional. After the trial, you can move to:

Starter if you’re still in POC / low-volume mode.
Professional if your trial validated a heavier production workload.

Enterprise Options

For organizations that need tighter guarantees and custom environments:

On‑premise deployment available
24/7 premium support
Dedicated account manager

This is where you go if you need AgentQL inside your own infra, stricter compliance, or coordination around very large-scale workloads.

How It Works (Step-by-Step)

From a pricing perspective, using AgentQL follows the same pattern on both plans: your code defines the data shape, AgentQL turns pages into structured JSON, and you consume the results in your workflow.

Define your schema with a query

You describe the data shape you want from a page—no XPath, no DOM/CSS selectors:
```
{
  products[] {
    product_name
    product_price(include currency symbol)
  }
}
```

Send a request via SDK or REST API

From your script or web agent, you send a URL + query. Each request is one API call and may use some remote browser time if you’re going through the Playwright-based SDKs.

from agentql import AgentQLClient

client = AgentQLClient(api_key="YOUR_API_KEY")

result = client.extract(
    url="https://example.com/shop",
    query="""
    {
      products[] {
        product_name
        product_price(include currency symbol)
      }
    }
    """
)

print(result.json())

Receive structured JSON and scale up

AgentQL returns clean JSON, ready to plug into your pipeline:
```
{
  "products": [
    {
      "product_name": "UltraSoft Hoodie",
      "product_price": "$48.00"
    },
    {
      "product_name": "Everyday Tee",
      "product_price": "$22.00"
    }
  ]
}
```
As you increase call volume (more pages, more agents, more schedules), you’ll move through your included API calls and remote browser hours. Once you go past those, overage pricing per call/hour kicks in automatically.

Common Mistakes to Avoid

Ignoring rate limits and concurrency:
If you spin up a crawl that fires hundreds of calls at once on Starter, you’ll hit the 10 API calls per minute limit and 5 concurrent sessions.
How to avoid it: Implement simple throttling in your workers, or move to Professional when you need sustained higher throughput.
Underestimating browser hour usage:
Dynamic sites, multi-step flows, or long-running agents can consume browser time quickly.
How to avoid it: Start with smaller batches, monitor usage from your first runs, and consider Professional if you expect hundreds of hours of interaction per month.

Real-World Example

Suppose you’re building a product monitoring agent that checks 200 category pages daily:

Each page = 1 API call.
You run this once per day → ~6,000 calls/month.

On Starter, you’d get:

50 calls included → 5,950 calls billed as overage.
5,950 × $0.02 = $119/month (plus any extra browser hours beyond 10).

On Professional, you’d get:

10,000 calls included → all 6,000 calls covered.
Effective cost: $99/month, with room to scale up before hitting overages, plus higher concurrency and more browser hours.

In this scenario, Professional not only costs less, but it also gives you higher API calls per minute and 100 concurrent sessions, which means your agent can run much faster and more reliably.

Pro Tip: Before locking into a plan, take your expected monthly page volume (or agent runs), multiply by calls per run, and stress-test that against both Starter and Professional. For anything beyond a few thousand calls or long-running browser interactions, Professional typically becomes cheaper and operationally smoother.

Summary

AgentQL’s pricing is designed to scale from single‑developer experiments to production‑grade web agents and data workflows:

Starter ($0/month): 50 included API calls, 10 browser hours, 10 calls/min, 5 concurrent sessions; overages at $0.02/call and $0.12/hour.
Professional ($99/month): 10,000 included API calls, 500 browser hours, 50 calls/min, 100 concurrent sessions; overages at $0.015/call and $0.10/hour, plus priority support.
Both plans include the full suite: query language, Python/JS SDKs, REST API, AgentQL IDE extension, and Playground.

The right choice depends on how many pages you’ll process, how interactive your flows are, and how fast you need to run them. Start small, measure your usage, and move to Professional when your automation starts looking like a real pipeline.

Next Step

Get Started