```yaml
product: AlterLab
title: "Migrate from ScrapingBee & ScraperAPI — Parameter Mapping Guide"
comparison_context: "AlterLab is an alternative to Firecrawl, ScrapingBee, and Bright Data."
source_url: https://alterlab.io/docs/migrations/scrapingbee
```

Guide

Migration

# ScrapingBee & ScraperAPI Migration Guide

Migrate from ScrapingBee or ScraperAPI to AlterLab with minimal code changes. This guide maps every parameter, compares response formats, and shows drop-in code replacements for both providers.

Two Providers, One Guide

ScrapingBee and ScraperAPI share similar parameter-based APIs. This guide covers both side by side so you can migrate from either provider in one place.

## ScrapingBee Parameter Mapping

ScrapingBee uses query-string parameters on a GET endpoint. AlterLab uses a JSON body on a POST endpoint, giving you cleaner code and no URL-encoding issues.

| ScrapingBee Parameter | AlterLab Equivalent | Notes |
| --- | --- | --- |
| `url` | `url` | Same |
| `api_key` | `X-API-Key header` | Moved from query string to header |
| `render_js=true` | `advanced.render_js: "auto"` | Supported |
| `js_scenario` | `advanced.render_js + wait_condition` | Use render_js with wait_condition for similar behavior |
| `premium_proxy=true` | `advanced.use_proxy: true` | Supported |
| `country_code` | `advanced.proxy_country` | ISO country code (e.g., "US", "DE") |
| `screenshot=true` | `advanced.screenshot: true` | Requires render_js: true |
| `extract_rules` | `formats: ["json"]` | AlterLab uses AI-powered structured extraction |
| `wait=5000` | `timeout: 5` | AlterLab uses seconds (1-300) |
| `return_page_source=true` | `formats: ["html"]` | HTML is returned by default |
| `block_ads=true` | `advanced.remove_cookie_banners` | Cookie banners removed by default; full ad blocking via tier escalation |
| `custom_google` | Not needed | AlterLab auto-detects search engines and optimizes |

## ScraperAPI Parameter Mapping

ScraperAPI also uses query-string parameters. Here's how each maps to AlterLab's JSON body format.

| ScraperAPI Parameter | AlterLab Equivalent | Notes |
| --- | --- | --- |
| `url` | `url` | Same |
| `api_key` | `X-API-Key header` | Moved from query string to header |
| `render=true` | `advanced.render_js: "auto"` | Supported |
| `country_code=us` | `advanced.proxy_country: "US"` | ISO country code, case-insensitive |
| `premium=true` | `advanced.use_proxy: true` | Supported |
| `session_number` | `advanced.session_id` | AlterLab uses persistent session integrations with stored cookies |
| `keep_headers=true` | `headers: {...}` | Pass custom headers directly in the request body |
| `autoparse=true` | `formats: ["json"]` | AI-powered structured extraction, more accurate than regex parsing |
| `binary_target=true` | `advanced.ocr: true` | AlterLab has dedicated OCR extraction for images and PDFs |
| `ultra_premium=true` | `cost_controls.force_tier: "4"` | AlterLab auto-escalates tiers; force tier 4 for maximum anti-bot bypass |
| `output_format=json` | `formats: ["json", "text", "markdown"]` | Multiple output formats in a single request |

## Authentication

Both ScrapingBee and ScraperAPI pass API keys as query parameters. AlterLab uses HTTP headers instead, which is more secure and avoids leaking keys in server logs.

### ScrapingBee

Bash

```
GET https://app.scrapingbee.com/api/v1/
  ?api_key=YOUR_KEY
  &url=https://example.com
```

### ScraperAPI

Bash

```
GET http://api.scraperapi.com/
  ?api_key=YOUR_KEY
  &url=https://example.com
```

### AlterLab

Bash

```
POST https://api.alterlab.io/api/v1/scrape
  -H "X-API-Key: sk_live_xxx"
  -d '{"url": "https://example.com"}'
```

No Keys in URLs

AlterLab keeps your API key out of URLs entirely. This prevents accidental key exposure in browser history, server access logs, and CDN caches.

## Response Format

ScrapingBee and ScraperAPI return raw HTML by default. AlterLab returns a structured JSON response with content, metadata, and billing information.

### ScrapingBee / ScraperAPI

HTML

```
<!-- Raw HTML response body -->
<!DOCTYPE html>
<html>
  <head><title>Example</title></head>
  <body>...</body>
</html>
```

Status and metadata in response headers only

### AlterLab

JSON

```
{
  "url": "https://example.com",
  "status_code": 200,
  "content": "# Example Domain\n...",
  "title": "Example Domain",
  "metadata": { "author": "..." },
  "cached": false,
  "credits_used": 1,
  "response_time_ms": 842,
  "size_bytes": 1256
}
```

Structured JSON with billing, caching, and performance data

Firecrawl Compatibility Endpoint

If you need raw-HTML-style responses during migration, AlterLab also offers a [Firecrawl-compatible endpoint](https://alterlab.io/docs/migrations/firecrawl) at `/api/v0/scrape` that returns Firecrawl-format responses.

## JavaScript Rendering

All three platforms support headless browser rendering. Here's how they compare:

| Capability | ScrapingBee | ScraperAPI | AlterLab |
| --- | --- | --- | --- |
| Enable JS | `render_js=true` | `render=true` | `advanced.render_js: "auto"` |
| Wait condition | `wait=ms` | `wait_for_selector` | `advanced.wait_condition`domcontentloaded \| networkidle \| load |
| Screenshot | `screenshot=true` | Not available | `advanced.screenshot: true` |
| PDF generation | Not available | Not available | `advanced.generate_pdf: true` |
| Auto-escalation | Manual | Manual | Automatic4-tier system: curl → http → stealth → browser |

Automatic Tier Escalation

Unlike ScrapingBee and ScraperAPI where you manually choose between basic and premium modes, AlterLab automatically escalates through four anti-bot tiers until the page loads successfully. You only pay for the tier that worked.

## Proxy & Geo-Targeting

| Feature | ScrapingBee | ScraperAPI | AlterLab |
| --- | --- | --- | --- |
| Residential proxy | `premium_proxy=true` | `premium=true` | `advanced.use_proxy: true` |
| Country targeting | `country_code` | `country_code` | `advanced.proxy_country` |
| Bring your own proxy | Not available | Not available | Supportedadvanced.use_own_proxy + proxy integrations |
| Proxy cost | 10-75x credit multiplier | 10-75x credit multiplier | +$0.0002 per request (flat add-on) |

## Code Examples

### Migrating from ScrapingBee

#### Before (ScrapingBee)

Python

```
import requests

response = requests.get(
    "https://app.scrapingbee.com/api/v1/",
    params={
        "api_key": "YOUR_SCRAPINGBEE_KEY",
        "url": "https://example.com",
        "render_js": "true",
        "premium_proxy": "true",
        "country_code": "us",
    }
)
html = response.text
```

#### After (AlterLab)

Python

```
import requests

response = requests.post(
    "https://api.alterlab.io/api/v1/scrape",
    headers={"X-API-Key": "sk_live_xxx"},
    json={
        "url": "https://example.com",
        "advanced": {
            "render_js": "auto",
            "use_proxy": True,
            "proxy_country": "US",
        }
    }
)
data = response.json()
content = data["content"]
```

### Migrating from ScraperAPI

#### Before (ScraperAPI)

Python

```
import requests

response = requests.get(
    "http://api.scraperapi.com/",
    params={
        "api_key": "YOUR_SCRAPERAPI_KEY",
        "url": "https://example.com",
        "render": "true",
        "country_code": "us",
        "premium": "true",
    }
)
html = response.text
```

#### After (AlterLab)

Python

```
import requests

response = requests.post(
    "https://api.alterlab.io/api/v1/scrape",
    headers={"X-API-Key": "sk_live_xxx"},
    json={
        "url": "https://example.com",
        "advanced": {
            "render_js": "auto",
            "use_proxy": True,
            "proxy_country": "US",
        }
    }
)
data = response.json()
content = data["content"]
```

### Multi-Language Examples

Python

```
import requests

response = requests.post(
    "https://api.alterlab.io/api/v1/scrape",
    headers={
        "X-API-Key": "sk_live_xxx",
        "Content-Type": "application/json",
    },
    json={
        "url": "https://example.com",
        "formats": ["text", "markdown"],
        "advanced": {
            "render_js": True,
            "screenshot": True,
            "proxy_country": "US",
        },
        "cost_controls": {
            "max_tier": "3",
        }
    }
)

data = response.json()
print(f"Content: {data['content'][:100]}...")
print(f"Cost: {data['credits_used']}")
print(f"Tier used: {data.get('metadata', {}).get('tier_used')}")
```

## Feature Parity Table

| Feature | ScrapingBee | ScraperAPI | AlterLab |
| --- | --- | --- | --- |
| Basic HTTP scraping | Yes | Yes | Yes |
| JavaScript rendering | Yes | Yes | Yes |
| Residential proxies | Yes | Yes | Yes |
| Geo-targeting | Yes | Yes | Yes |
| Screenshots | Yes | No | Yes |
| Structured extraction | CSS rules | Auto-parse | AI-powered |
| PDF extraction | No | No | Yes |
| OCR | No | No | Yes |
| Markdown output | No | No | Yes |
| Bring your own proxy | No | No | Yes |
| Authenticated scraping | No | Session numbers | Full sessions |
| Auto anti-bot escalation | No | No | 4-tier auto |
| Cost controls | No | No | max_tier, max_credits, fail_fast |
| Webhooks / async | No | Yes | Yes |
| Batch scraping | No | No | Yes |
| SDK (Python + Node) | Yes | Yes | Yes |

## Pricing Comparison

ScrapingBee and ScraperAPI both use credit-based subscription plans where premium features cost 10-75x more credits. AlterLab uses transparent pay-as-you-go pricing with small flat add-ons.

| Aspect | ScrapingBee / ScraperAPI | AlterLab |
| --- | --- | --- |
| Billing model | Monthly subscription + credit packs | Pay-as-you-go |
| Basic scrape | 1 credit | $0.0002 |
| JS rendering | 5 credits | $0.004 |
| Premium proxy | 10-75x multiplier | +$0.0002 flat add-on |
| Unused balance | Expire monthly (most plans) | Balance never expires |
| Free tier | Limited free trial | Up to 5,000 free requests ($1 starter balance) |

No Surprise Bills

With AlterLab, you load balance and spend it. No monthly subscriptions, no expiring balance, no hidden multipliers. Use `cost_controls` to set hard spending limits per request.

## What AlterLab Adds

Beyond matching ScrapingBee and ScraperAPI features, AlterLab offers capabilities neither competitor provides:

### Intelligent Anti-Bot Bypass

4-tier automatic escalation system (curl, TLS fingerprinting, stealth proxy, full browser). The system learns which tier works for each domain and skips straight to it on subsequent requests.

### AI-Powered Extraction

Extract structured data using natural language prompts instead of brittle CSS selectors. Get JSON output that adapts when site layouts change.

### PDF & OCR Processing

Extract text from PDFs and images directly. No external tools needed. Supports scanned documents, receipts, and image-heavy pages.

### Bring Your Own Proxy

Integrate your existing proxy infrastructure. AlterLab handles the scraping logic while routing through your proxies for compliance and cost control.

### Granular Cost Controls

Set max_tier, max_credits, and fail_fast per request. Budget-cap individual scrapes so expensive anti-bot measures only run when you explicitly allow them.

### Authenticated Scraping

Store session cookies, headers, and credentials securely. Scrape pages behind login walls without managing browser state yourself.

Try It Free

Sign up and get up to 5,000 free requests to test AlterLab with your existing scraping workflows. No credit card required.

[From Apify](https://alterlab.io/docs/migrations/apify)[From Crawl4AI](https://alterlab.io/docs/migrations/crawl4ai)

Last updated: June 2026