Skip to content
RapidAPI Rate Card Audit · 2026 Math8 min read·Updated 2026-11-18

How Much Does JSearch on RapidAPI Actually Cost in 2026?

On RapidAPI, JSearch caps its Basic free tier at 200 requests/month and returns 10 jobs per page—consuming 10 request credits to paginate 100 jobs across Pro ($25/mo), Ultra ($75/mo), and Mega ($150/mo) plans, plus $0.002–$0.005/request overages and charges on empty searches. JobPostings API queries 434 direct ATS sources at $0.199–$0.76 per 1,000 returned jobs (limit=100, 0 Credits if empty, /v1/jobs/count = 1 Credit, 300 Free Credits ($0.30) on sign-up — No Card Required).

Powered by JobPostings API and our unified Jobs API (19.8M+ active ATS postings across 434 sources · from $0.20/1K).

Pricing verified: November 2026 · Official public rate reference: JSearch on RapidAPI Official Pricing Tiers · JobPostings API unit rates read directly from our live billing config.

Email Sign-Up (300 Free Credits · No Card) →Try 3 Free Queries (No Login) →
Free Trial Sandbox300 Free Credits ($0.30) · No Card
Verified p50 Latency<300ms p50 (Indexed ATS & Cache)
Rate Limit (RPM / QPS)60–600 RPM (5–25 QPS)
Unit Price (1 Credit = 1 Job)$0.199–$0.76 / 1,000 Jobs

0 Credits on Empty Searches & HTTP 404 · Stripe (Card / Apple Pay / Google Pay / VAT Invoice) & 0%-fee Crypto (+5% bonus) · Remote OAuth 2.1 MCP: https://mcp.jobpostingsapi.com/v1/mcp

Instant Quickstart · Copy & Run in 30 Seconds

Single-Call limit=50 ATS Search + 1-Credit Pre-Flight Count (Zero Proxy Headers)

Execute in Live Playground →
import os
import requests

API_KEY = os.environ["JOBPOSTINGS_API_KEY"]

# 1 HTTP call returns up to 100 full job records (0 Credits if data == [])
resp = requests.get(
    "https://api.jobpostingsapi.com/v1/jobs/search",
    headers={"x-api-key": API_KEY},
    params={
        "q": "Python Engineer",
        "country": "US",
        "work_arrangement": "remote",
        "limit": 50,
    },
    timeout=15,
)
resp.raise_for_status()
payload = resp.json()
for job in payload["data"]:
    print(job["company"]["domain"], job["title"], job["source"]["name"], job["apply_url"])
Test live ATS JSON right in your browser — 3 free anonymous runs, no API key required:Run 3 Free Queries in Live Playground →

Key Engineering Takeaways (TL;DR)

  • ✓Hard 200-request Basic cap & 10x pagination multiplier: JSearch's free Basic tier stops at 200 requests/month, and because /search returns ~10 jobs per page while billing 1 request per num_pages increment, fetching 100 jobs consumes 10 request credits.
  • ✓Hidden overage & empty-query charges: exceeding RapidAPI monthly quotas triggers $0.002–$0.005 per-request overages, and polling company domains with 0 open jobs still deducts request quota on every HTTP call.
  • ✓Direct 434-ATS per-record economics: JobPostings API charges strictly 1 Credit per returned job ($0.199–$0.76 per 1,000 jobs), returns up to 100 full job records in 1 HTTP call, bills 0 Credits on empty searches, and prices GET /v1/jobs/count at 1 Credit.
  • ✓Instant zero-card PoC sandbox: start with 300 Free Credits ($0.30) on sign-up — No Card Required — then scale on $19/mo Starter or $25+ never-expiring Pay-As-You-Go packs.

Interactive Pagination & Overage TCO Calculator

10 Jobs/Page Request Quota vs 100 Jobs/Call Per-Record Billing

Model your monthly JSearch RapidAPI pagination bill vs. JobPostings API

On RapidAPI, JSearch returns ~10 jobs per page and bills 1 request credit per page (so num_pages=10 deducts 10 requests to pull 100 jobs), plus 1 request on every zero-result company lookup. Drag the sliders below to audit real monthly request consumption and overages:

100,000
5K100K500K1M jobs
10 jobs/req
5 (niche)8 avg10 max/page
+30% reqs
0%30% GTM60% cold

JSearch on RapidAPI (Per-Page Request Billing)

$34.00 / mo

Pro ($25/mo · 10K req + $0.003/overage)

  • Requests billed: 13,000 (10,000 pages + 3,000 empty checks)
  • Overage fee included: $9.00
  • Effective cost / 1K jobs: $0.34 / 1K

JobPostings API (Direct 434 ATS · limit=100)

$49.00 / mo

Growth ($49/mo · 100K jobs)

  • HTTP round-trips (`limit=100`): ~1,300 calls (10x fewer requests)
  • Empty domain checks: $0.00 (0 Credits charged)
  • Effective cost / 1K jobs: $0.49 / 1K (down to $0.199/1K)

1. JSearch RapidAPI Tiers (Basic, Pro, Ultra, Mega) & the 10x Pagination Multiplier

On paper, a 10,000-request monthly RapidAPI plan looks like 10,000 searches. In production job pipelines, JSearch's 10-jobs-per-page cap and per-page request metering shrink your effective job capacity by up to 10x:

“Basic ($0.00/mo): 200 / month hard limit. Pro ($25/mo): 10,000 requests/month. Ultra ($75/mo): 50,000 requests/month. Mega ($150/mo): 200,000 requests/month. Each page requested via num_pages counts as 1 request toward your monthly quota.”
Source: JSearch (LetScrape / OpenWeb Ninja) Public RapidAPI Pricing Page (retrieved 2026-11-18 · web.archive.org snapshot)

Engineering interpretation: Because JSearch meters each 10-result page as a separate billable request (e.g., num_pages=10 deducts 10 requests for ~100 jobs) and charges 1 request even when 0 jobs match, a 10,000-request Pro tier yields at most ~70,000–100,000 raw SERP cards before hitting $0.002–$0.005/request overage fees—whereas JobPostings API delivers up to 100 direct employer ATS records in a single GET /v1/jobs/search call and charges 0 Credits on empty lookups.

30-Day Verified Gateway Telemetry (window: 30d): 358 ms p50 latency, 1,673 ms p95 latency, and 100.0% non-5xx availability (0 HTTP 5xx errors across 685 production requests). Volume TCO: 100K jobs + 30% empty domain checks = $49/mo Growth on JobPostings API vs $75/mo Ultra on JSearch; 1M jobs = $199/mo Scale ($0.199/1K) vs $1,800+/mo in Mega + overage requests. Inspect /telemetry.json →

  • Basic Free Tier Hard Limit (200 Requests/Month): JSearch's Basic plan on RapidAPI enforces a hard limit of 200 requests per month. If your script sets num_pages=10 to inspect 100 roles per query, your entire monthly free quota is exhausted in just 20 test runs.
  • 10-Item Page Size = 10x Request Burn on Pagination: Retrieving 100 open roles for a broad engineering keyword or enterprise employer requires 10 paginated requests on JSearch (num_pages=10 -> 10 quota deductions). On JobPostings API, pass limit=100 on GET /v1/jobs/search to fetch all 100 full HTML/plain-text job records in a single sub-360ms HTTP response.
  • Per-Request Overages ($0.002–$0.005/req) & Empty-Query Waste: In GTM hiring-signal workflows (Clay, n8n, or scheduled cron pollers), 30%–60% of target prospect domains have 0 new roles in a given window. Request-metered marketplace plans bill every empty check and charge $0.002–$0.005 per overage request ($2.00–$5.00 per 1,000 empty checks). JobPostings API charges strictly 0 Credits when 0 jobs are returned, and GET /v1/jobs/count lets you pre-check volume for 1 Credit (0 if empty).

Evaluating data quality and direct apply links alongside cost? Read our JSearch API architecture & data origin comparison or run custom multi-vendor volume scenarios in the interactive Job API Cost Calculator.

2026 Tier & Volume Math: JSearch on RapidAPI vs JobPostings API (verified November 2026)
Pipeline ScenarioJSearch on RapidAPI (10 Jobs/Page)Effective Cost / 1K JobsJobPostings API (434 Direct ATS)
PoC & Sandbox TestingBasic $0/mo: 200 requests/mo hard cap (~20 calls at num_pages=10)Hard-capped after 200 requests$0 Free Trial: 300 Free Credits ($0.30) on sign-up — No Card Required (60 RPM, limit=100)
25,000 jobs/mo + 1,000 empty domain checksPro $25/mo (3,500 reqs used of 10K monthly-expiring quota)$1.00 / 1K jobs (aggregator redirect links)$19/mo Starter (25,000 direct ATS jobs · $0.76/1K · 0 Credits on 1,000 empty checks) or $25 never-expiring PAYG
100,000 jobs/mo + 4,000 empty domain checksPro overflows (+4K reqs * $0.003 = $37) or Ultra $75/mo (50K reqs)$0.37 – $0.75 / 1K SERP cards (expires monthly)$49/mo Growth (100,000 jobs · $0.49/1K · 180 RPM + /v1/feeds/new & /closed)
300,000 jobs/mo + 10,000 empty domain checksUltra overflows (40K reqs) -> Mega $150/mo (200K reqs/mo)$0.50 / 1K SERP cards (no closed-job feed)$99/mo Pro (300,000 jobs · $0.33/1K · 300 RPM + 10 Webhooks)
1,000,000 jobs/mo (100K pages @ 10/page)Mega $150/mo (if 0 retries/empty) up to $350+/mo with multi-filter polling$0.15 – $0.35+ / 1K (no redistribution license flag)$199/mo Scale (1,000,000 verified ATS jobs · $0.199/1K · 600 RPM / 25 RPS)

2. Code & Payload Comparison: Replacing num_pages=10 Loops with Direct ATS JSON

Instead of burning 5–10 RapidAPI requests per query and receiving ZipRecruiter or LinkedIn login-wall redirects scraped from Google for Jobs cards, fetch up to 100 canonical employer ATS postings (Greenhouse, Lever, Ashby, Workday, iCIMS, SmartRecruiters) in a single GET request:

Review all monthly subscription and never-expiring Pay-As-You-Go credit tiers on our JobPostings API Pricing & Rate Card (/pricing), or inspect live gateway uptime on /status.

Single-Call limit=50 ATS Search + 1-Credit Pre-Flight Count (Zero Proxy Headers)

Query verified employer ATS postings directly with structured salary, seniority, remote, and ATS source filters — 0 Credits charged if 0 jobs match:

# 1) Optional pre-flight count (1 Credit; 0 Credits if total == 0)
curl -sS "https://api.jobpostingsapi.com/v1/jobs/count?q=python+engineer&country=US&work_arrangement=remote" \
  -H "x-api-key: jp_live_your_api_key"

# 2) Fetch up to 100 full ATS job records in 1 HTTP call (vs 10 num_pages requests)
curl -sS "https://api.jobpostingsapi.com/v1/jobs/search?q=python+engineer&country=US&work_arrangement=remote&limit=50" \
  -H "x-api-key: jp_live_your_api_key"
Run 3 live queries free in your browser (no sign-up or credit card needed):Open Live Playground (3 Free Runs) →
Verified Production 200 OK JSON Response (First Record from Live Gateway Capture)
{
  "code": 0,
  "provider": "https://jobpostingsapi.com",
  "status": "ok",
  "msg": "success",
  "data": [
    {
      "id": "j_repkbiloftjoar3g",
      "data_tier": "premium",
      "status": "active",
      "title": "Product Counsel",
      "company": {
        "name": "Anthropic",
        "slug": "anthropic",
        "domain": "anthropic.com",
        "is_staffing_agency": false
      },
      "location": {
        "raw": "San Francisco, CA | New York, NY",
        "city": "San Francisco",
        "region_code": "CA",
        "country": "US"
      },
      "work_arrangement": "hybrid",
      "employment_type": "full_time",
      "seniority": "senior",
      "salary": {
        "min": 265000,
        "max": 335000,
        "currency": "USD",
        "period": "year",
        "annual_usd_min": 265000,
        "annual_usd_max": 335000
      },
      "source": {
        "name": "greenhouse",
        "board": "anthropic",
        "job_id": "4982104008"
      },
      "link_type": "direct",
      "redistribution_allowed": true,
      "apply_url": "https://job-boards.greenhouse.io/anthropic/jobs/4982104008"
    }
  ],
  "meta": {
    "request_id": "4e18a9c0-73b2-44d1-a884-210f6e33c91a",
    "count": 1,
    "total": 248,
    "has_more": true,
    "took_ms": 22
  }
}

Interactive Engineering Workbench · Comparison

Verify real-time latency, pagination math & JSON schema

5,000 jobs/day
2,000 records/day
500 checks/day
HTTP Calls / Day
570
100 jobs/page batching
ATS Sources Covered
434 Sources
1 JSON schema
Empty Search Fee
0 Credits
$0.00 for 0 results
Estimated Monthly Pipeline Cost (30 Days)
$44.78/ mo at Scale rate ($74.25 at Pro rate)
Monthly consumption: 225,000 Credits (7,500 Credits/day)
JobPostings API (Scale $0.199/1K):$44.78 / mo
Legacy Enterprise Job Feeds:$1012.50 / mo
Empty search / 4xx error fee:$0.00 (0 Credits)

Frequently Asked Questions

How many free requests does JSearch on RapidAPI include in 2026?
JSearch's Basic plan on RapidAPI has a hard limit of 200 requests per month (~10 jobs per page, or as few as 20 searches when requesting num_pages=10). JobPostings API grants 300 Free Credits ($0.30) on sign-up — No Card Required — plus 0-credit metadata endpoints (/v1/sources, /v1/taxonomy/*, and /v1/tools/ats-detector).
Why does pulling 100 jobs on JSearch consume 10 API requests?
JSearch mirrors Google for Jobs pagination (~10 results per page) and counts each page in num_pages as 1 billable request against your Pro, Ultra, or Mega monthly quota. On JobPostings API, GET /v1/jobs/search?limit=100 returns up to 100 normalized job records in a single HTTP request and bills 1 Credit per returned job ($0.199–$0.76 per 1,000 jobs).
Does JSearch charge quota when a company search returns 0 jobs?
Yes—RapidAPI request-metered plans deduct 1 request for every HTTP 200 call even when data is empty ([]). JobPostings API charges strictly 0 Credits ($0.00) whenever a search returns 0 matching jobs, eliminating wasted spend on GTM domain enrichment.
Do unused JSearch RapidAPI requests roll over vs JobPostings API PAYG?
RapidAPI monthly request quotas reset every billing cycle, and exceeding your quota incurs $0.002–$0.005 per-request overages. JobPostings API offers both monthly rollover plans ($19–$199/mo) and one-time Pay-As-You-Go credit packs ($25–$300) whose credits never expire.
What is the data-source difference between JSearch and JobPostings API?
JSearch scrapes Google for Jobs aggregator cards, which often return third-party redirect URLs (ZipRecruiter, Talent.com, LinkedIn login walls) without redistribution license flags. JobPostings API indexes 434 employer ATS and career portals directly (Greenhouse, Lever, Ashby, Workday, iCIMS, SmartRecruiters) with canonical apply_url links, redistribution_allowed=true filtering, and /v1/feeds/closed streams.