Rate Limits & Parallel Lanes

SearchCans has no hard hourly cap. Your throughput is determined by <strong>Parallel Lanes</strong> — the number of requests that can run at the same time. Eligible plans can be combined via Lane Stacking.

How Parallel Lanes Work

Starter Plan — 3 Parallel Lanes

Lane 1

q="world cup 2026"

running

Lane 2

url="bbc.com/sport"

running

Lane 3

idle — ready

free

When Lane 1 finishes, it immediately accepts the next request in your queue. No hourly reset, no waiting.

API Code 1010 — Lane Limit Exceeded

Returned inside the JSON body (HTTP 200) when all your lanes are busy. Not fatal — retry after 100–500 ms. The best solution is to cap your concurrency to your lane count using a Semaphore so 1010 never appears.

HTTP 429 — Transport-Level Rate Limit

Less common than 1010. Applies when the request is rejected at the HTTP layer before reaching the API logic. Same remedy: queue your requests or upgrade your plan.

Lane Stacking — Combine Plans

Starter (3) + Starter (3) = 6 Lanes

Pro (22) + Starter (3) = 25 Lanes

Standard ($18) plan is not eligible for Lane Stacking.

Concurrent Requests

import asyncio, aiohttp

API_KEY = "YOUR_API_KEY"
URL = "https://www.searchcans.com/api/v1/search"

queries = [
    "world cup 2026 schedule",
    "best SERP API 2026",
    "python web scraping tools",
    # … add more queries as needed
]

async def search_one(session, query):
    async with session.post(
        URL,
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={"t": "google", "s": query},
    ) as r:
        body = await r.json()
        return body["data"] if body["code"] == 0 else None

async def main():
    # Set Semaphore to your plan's Parallel Lane count
    sem = asyncio.Semaphore(3)   # Starter plan = 3 lanes

    async def bounded(session, q):
        async with sem:
            return await search_one(session, q)

    async with aiohttp.ClientSession() as session:
        results = await asyncio.gather(
            *[bounded(session, q) for q in queries]
        )
    return results

results = asyncio.run(main())

// npm install p-limit
import pLimit from 'p-limit';

const API_KEY = 'YOUR_API_KEY';
const URL = 'https://www.searchcans.com/api/v1/search';

const queries = [
  'world cup 2026 schedule',
  'best SERP API 2026',
  'python web scraping tools',
];

async function searchOne(query) {
  const res = await fetch(URL, {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer ' + API_KEY,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ t: 'google', s: query }),
  });
  const body = await res.json();
  return body.code === 0 ? body.data : null;
}

// Set limit to your plan's Parallel Lane count
const limit = pLimit(3);  // Starter plan = 3 lanes

const results = await Promise.all(
  queries.map(q => limit(() => searchOne(q)))
);
console.log(results);

Set Semaphore(N) / pLimit(N) to your plan's Parallel Lane count. This prevents 1010 lane-busy errors entirely.

Parallel Lanes by Plan

Throughput estimate assumes ~3-second average response time per request.

Plan	Price	Credits	Parallel Lanes	~Req/hr	Lane Stacking	Per 1K
Free	$0	100	1 lane	~1.2K	No	—
Standard	$18	20K	2 lanes	~2.4K	No	$0.90
Starter Popular	$99	132K	3 lanes	~3.6K	Yes	$0.75
Pro	$597	~1M	+16 22 lanes	~26.4K	Yes	$0.60
Ultimate	$1,680	3M	+62 68 lanes	~81.6K	Yes	$0.56

Key Concepts

No Hourly Cap

There is no fixed number of requests per hour. You can burst as fast as your lanes allow, 24/7, with no resets or cooldowns.

Lane Stacking

Starter, Pro, and Ultimate plans are eligible for Lane Stacking: buy multiple plans and the lanes add together under a single API key.

Credits Only on Success

Credits are consumed only when a request returns HTTP 200. Timeout (-1001), auth errors, and 429s do not deduct credits.

FIFO Credit Consumption

When you have multiple active plans, credits are consumed FIFO (oldest purchase first), ensuring none expire unnoticed. Credits are valid for 6 months.

Need more throughput?

Upgrade your plan or stack multiple Starter plans for instant lane expansion.

View Pricing & Plans Get Free API Key