Anti-Detection Technology

How Carapis reliably accesses car marketplaces — so you never build or maintain a scraper.

Overview

Many car marketplaces are JavaScript-rendered, sit behind private app APIs, and apply regional access controls and anti-bot measures. Carapis uses enterprise-grade anti-detection infrastructure to access 200+ car marketplaces reliably. All of that complexity is handled for you — you just call the API.

Technology stack

Residential proxy network

• Large pool of residential IPs across regions
• Geographic distribution matching where each marketplace operates (East Asia, Europe, North America, Eastern Europe)
• Automatic IP rotation per request
• High first-attempt success rate
• Low-latency response times

Browser fingerprinting

Randomized browser characteristics so requests look like real visitors:

• User agents (Chrome, Firefox, Safari variations)
• Screen resolutions and color depths
• Timezone and language settings
• Plugin configurations
• Canvas and WebGL fingerprints

Request management

Intelligent rate limiting tuned per marketplace:

• Platform-specific rate limits respected
• Distributed request timing
• Automatic retry with exponential backoff
• Request queue management
• Peak-hour load balancing

How it works

Request flow

Your API call → Carapis gateway → Proxy selection → Car marketplace → Response

Each request is:

1. Routed through a region-appropriate residential proxy
2. Assigned a randomized browser fingerprint
3. Sent with realistic headers and timing
4. Validated and normalized into the Carapis vehicle schema
5. Returned to you as clean JSON

Automatic handling

Carapis automatically handles:

• IP rotation and proxy selection
• CAPTCHA solving (when encountered)
• Cookie and session management
• JavaScript rendering and private app APIs
• Regional access controls
• Marketplace HTML/structure changes

Reliability features

High success rate

Achieved through:

• Multi-proxy fallback chains
• Real-time marketplace monitoring
• Automatic adaptation to site changes
• Dedicated infrastructure per marketplace

Zero maintenance

You never worry about:

• Proxy management
• Rate-limit tuning per marketplace
• Marketplace HTML changes
• Anti-bot updates
• Infrastructure scaling

Compliance

Responsible data extraction:

• Publicly available listing data only
• Respects robots.txt where applicable
• Rate limiting prevents server overload
• Terms-of-service-conscious methods

Best practices

Prefer bulk endpoints

Pull many listings in one call instead of one-at-a-time requests:

import requests
 
resp = requests.get(
    "https://api.carapis.com/v2/listings",
    params={"source": "encar", "make": "Hyundai", "limit": 1000},
    headers={"Authorization": f"Bearer {API_KEY}"},
)
listings = resp.json()["results"]

Cache frequently accessed data

Reduce calls by caching listings that don’t change minute-to-minute:

from functools import lru_cache
 
 
@lru_cache(maxsize=1000)
def get_listing_cached(listing_id):
    resp = requests.get(
        f"https://api.carapis.com/v2/listings/{listing_id}",
        headers={"Authorization": f"Bearer {API_KEY}"},
    )
    return resp.json()

Use webhooks for fresh inventory

Instead of polling, subscribe to new listings:

requests.post(
    "https://api.carapis.com/v2/webhooks",
    json={
        "event": "new_listing",
        "url": "https://yourapp.com/webhook/new-listing",
        "filters": {"source": "encar", "make": "Genesis"},
    },
    headers={"Authorization": f"Bearer {API_KEY}"},
)

Rate limits

Rate limits scale with your plan tier. As a guideline:

• Starter: lower per-minute throughput, good for prototyping
• Professional: higher throughput for production workloads
• Enterprise: highest throughput plus dedicated capacity

See the pricing page for current limits.

Staying within limits

• Spread requests over time
• Use bulk endpoints
• Cache results
• Implement exponential backoff

Get started

All anti-detection is handled automatically — you just authenticate and query:

import requests
 
API_KEY = "your_carapis_key"
 
resp = requests.get(
    "https://api.carapis.com/v2/listings",
    params={"source": "encar", "limit": 20},
    headers={"Authorization": f"Bearer {API_KEY}"},
)
for car in resp.json()["results"]:
    print(car["make"], car["model"], car["year"], car["price"])

For the full API surface, see the API reference.