Smart Proxy · Documentation Crawlbase

Point de terminaison

PROXYsmartproxy.crawlbase.com:8012

# Username = votre token. Password = vide.
# Prend en charge les cibles HTTP et HTTPS. Utilisez le mode proxy HTTPS pour les cibles HTTPS.

Démarrage rapide

Définissez Smart Proxy comme proxy dans votre client HTTP. C'est toute la configuration.

curl -x 'http://YOUR_TOKEN:@smartproxy.crawlbase.com:8012' \
     -k 'https://httpbin.org/ip'
import requests

proxies = {
    'http':  'http://YOUR_TOKEN:@smartproxy.crawlbase.com:8012',
    'https': 'http://YOUR_TOKEN:@smartproxy.crawlbase.com:8012',
}
res = requests.get('https://httpbin.org/ip', proxies=proxies, verify=False)
print(res.text)
const { HttpsProxyAgent } = require('https-proxy-agent');

const agent = new HttpsProxyAgent(
  'http://YOUR_TOKEN:@smartproxy.crawlbase.com:8012'
);

const res = await fetch('https://httpbin.org/ip', { agent });
console.log(await res.text());
require 'net/http'

uri = URI('https://httpbin.org/ip')
proxy = Net::HTTP::Proxy('smartproxy.crawlbase.com', 8012, 'YOUR_TOKEN', '')
http = proxy.new(uri.host, uri.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
puts http.get(uri.request_uri).body
package main

import (
    "crypto/tls"
    "fmt"
    "io"
    "net/http"
    "net/url"
)

func main() {
    proxyURL, _ := url.Parse("http://YOUR_TOKEN:@smartproxy.crawlbase.com:8012")
    client := &http.Client{Transport: &http.Transport{
        Proxy:           http.ProxyURL(proxyURL),
        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    }}
    res, _ := client.Get("https://httpbin.org/ip")
    body, _ := io.ReadAll(res.Body)
    fmt.Println(string(body))
}

Désactiver la vérification TLS

Smart Proxy intercepte les connexions TLS pour ajouter des en-têtes proxy. Votre client verra le certificat de Crawlbase au lieu de celui de la cible, donc définissez verify=False / InsecureSkipVerify: true / équivalent. La connexion entre Crawlbase et le site cible reste vérifiée.

Requêtes POST

Smart Proxy transmet les requêtes POST à la cible comme n'importe quelle autre méthode HTTP. Définissez le proxy sur votre client et faites POST comme d'habitude — le proxy préserve votre méthode, vos en-têtes et votre body. Les exemples ci-dessous couvrent les deux formes de body les plus utilisées : form-encoded et JSON.

Body form-encoded

# HTTP proxy on :8012 (use https:// + :8013 for HTTPS proxy)
curl -X POST \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -F 'param=value' \
     -x 'http://[email protected]:8012' \
     -k 'https://httpbin.org/anything'

import requests
from urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(category=InsecureRequestWarning)

proxies = {
    'http':  'http://YOUR_TOKEN:@smartproxy.crawlbase.com:8012',
    'https': 'http://YOUR_TOKEN:@smartproxy.crawlbase.com:8012',
}
res = requests.post(
    'https://httpbin.org/anything',
    data={'param': 'value'},
    proxies=proxies,
    verify=False,
)
print(res.status_code, res.text)

const { HttpsProxyAgent } = require('https-proxy-agent');
const querystring = require('querystring');

const agent = new HttpsProxyAgent(
  'http://YOUR_TOKEN:@smartproxy.crawlbase.com:8012'
);
const res = await fetch('https://httpbin.org/anything', {
  method: 'POST',
  headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
  body: querystring.stringify({ param: 'value' }),
  agent,
});
console.log(res.status, await res.text());

require 'net/http'
require 'openssl'
require 'uri'

uri = URI('https://httpbin.org/anything')
proxy = Net::HTTP::Proxy('smartproxy.crawlbase.com', 8012, 'YOUR_TOKEN', '')
http = proxy.new(uri.host, uri.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

req = Net::HTTP::Post.new(uri.request_uri)
req.set_form_data('param' => 'value')
res = http.request(req)
puts res.code, res.body

package main

import (
    "crypto/tls"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strings"
)

func main() {
    proxyURL, _ := url.Parse("http://[email protected]:8012")
    client := &http.Client{Transport: &http.Transport{
        Proxy:           http.ProxyURL(proxyURL),
        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    }}

    data := url.Values{}
    data.Set("param", "value")
    req, _ := http.NewRequest("POST",
        "https://httpbin.org/anything",
        strings.NewReader(data.Encode()))
    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

    res, _ := client.Do(req)
    defer res.Body.Close()
    body, _ := io.ReadAll(res.Body)
    fmt.Println(res.Status, string(body))
}

Body JSON

curl -X POST \
     -H 'Content-Type: application/json' \
     --data '{"key1":"value1","key2":"value2"}' \
     -x 'http://[email protected]:8012' \
     -k 'https://httpbin.org/anything'

import requests
proxies = {
    'http':  'http://YOUR_TOKEN:@smartproxy.crawlbase.com:8012',
    'https': 'http://YOUR_TOKEN:@smartproxy.crawlbase.com:8012',
}
res = requests.post(
    'https://httpbin.org/anything',
    json={'key1': 'value1', 'key2': 'value2'},
    proxies=proxies,
    verify=False,
)
print(res.status_code, res.text)

const { HttpsProxyAgent } = require('https-proxy-agent');

const agent = new HttpsProxyAgent(
  'http://YOUR_TOKEN:@smartproxy.crawlbase.com:8012'
);
const res = await fetch('https://httpbin.org/anything', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ key1: 'value1', key2: 'value2' }),
  agent,
});
console.log(res.status, await res.text());

require 'net/http'
require 'json'
require 'openssl'
require 'uri'

uri = URI('https://httpbin.org/anything')
proxy = Net::HTTP::Proxy('smartproxy.crawlbase.com', 8012, 'YOUR_TOKEN', '')
http = proxy.new(uri.host, uri.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

req = Net::HTTP::Post.new(uri.request_uri,
                          'Content-Type' => 'application/json')
req.body = { key1: 'value1', key2: 'value2' }.to_json
puts http.request(req).body

Transmission des en-têtes et des cookies

Smart Proxy transmet la plupart des en-têtes et des cookies de votre requête sortante vers la cible, afin que les clients existants continuent de fonctionner sans modification. Deux comportements notables :

Votre User-Agent est transmis tel quel. Envoyez-en un vide et le proxy fera tourner un UA réaliste pour vous.
Les en-têtes hop-by-hop et de contrôle proxy (Host, Proxy-Authorization) sont supprimés — ils décrivent le proxy lui-même, pas la requête transmise.

curl -H 'Accept-Language: en-US,en;q=0.9' \
     -H 'X-Custom-Header: My-Custom-Value' \
     -H 'User-Agent: MyCustomBrowser/1.0' \
     --cookie 'sid=abc123; cart=xyz789' \
     -x 'http://[email protected]:8012' \
     -k 'https://httpbin.org/anything'

L'exemple ci-dessus arrive à la cible avec les quatre en-têtes personnalisés et les deux cookies intacts. Pour outrepasser le comportement du proxy (pays, device, session, rendu JS, scrapers, etc.), utilisez plutôt les en-têtes CrawlbaseAPI-* — ceux-ci sont interprétés par le proxy et n'atteignent jamais la cible.

Rendu en navigateur headless

Smart Proxy s'appuie sur la même flotte de navigateurs headless que la Crawling API. Pour exécuter du JavaScript, capturer des SPA rendus côté client ou appliquer des fonctionnalités de la Crawling API qui nécessitent un véritable navigateur (captures d'écran, scroll, click-selectors, autoparse), passez CrawlbaseAPI-Parameters: javascript=true en en-tête de votre requête sortante.

# Render with a headless browser, force a 2s wait, scroll to load lazy content
curl -H 'CrawlbaseAPI-Parameters: javascript=true&page_wait=2000&scroll=true' \
     -x 'http://[email protected]:8012' \
     -k 'https://spa.example.com/feed'

Utilisez votre JavaScript token (et non le Normal token) lorsque javascript=true est défini — ils sont facturés séparément. L'ensemble complet des paramètres de niveau navigateur (page_wait, scroll, css_click_selector, wait_for, captures d'écran) est accessible via CrawlbaseAPI-Parameters ; consultez la référence des paramètres JavaScript pour la liste canonique.

Quand utiliser Smart Proxy plutôt que la Crawling API

Smart Proxy et la Crawling API fonctionnent sur le même réseau et exposent la même surface fonctionnelle — rendu JS, contournement anti-bot, routage par pays, émulation de device, sessions, scrapers, async + storage, tout y est. Le choix entre les deux n'est pas une question de capacité ; il s'agit de la forme de l'interface, de l'abonnement que vous détenez et du palier de concurrence que cet abonnement fournit.

Choisissez Smart Proxy quand…	Choisissez la Crawling API (REST) quand…
Vous ne pouvez pas modifier le code client (outil tiers, extension de navigateur, Scrapy, un scraper existant)	Vous partez de zéro et souhaitez un contrôle explicite par requête
Vous préférez configurer un proxy une fois plutôt que de réécrire chaque requête vers un nouveau point de terminaison	Vous préférez voir l'URL et les paramètres en clair sous forme de GET pour la journalisation / le débogage
Votre abonnement est sur le plan Smart Proxy, avec son propre palier de threads / concurrence	Votre abonnement est sur le plan Crawling API, avec son propre quota mensuel et budget de concurrence
Vous voulez insérer Crawlbase devant un pipeline existant sans aucune modification de code	Vous voulez qu'un des SDKs gère pour vous les retries, le polling async et le parsing de la réponse

Tous les paramètres de la Crawling API sont accessibles depuis Smart Proxy via l'en-tête CrawlbaseAPI-Parameters (voir ci-dessous). La surface fonctionnelle est la même — choisissez la voie que votre abonnement et la forme de votre intégration favorisent.

En-têtes de contrôle

Passez des en-têtes personnalisés préfixés par CrawlbaseAPI- sur votre requête sortante pour contrôler le comportement du proxy. Les trois en-têtes mono-fonction ci-dessous sont des raccourcis pratiques ; l'ensemble complet des paramètres de la Crawling API est accessible via CrawlbaseAPI-Parameters (documenté après le tableau).

CrawlbaseAPI-Country

ISO 3166optionnel

Forcer un pays spécifique : US, GB, DE, etc.

CrawlbaseAPI-Device

desktop | mobiledesktop

Émuler la classe de device.

CrawlbaseAPI-Session-Id

stringoptionnel

Épingler une session à la même IP de sortie. Utile pour les flux multi-étapes nécessitant une identité stable. Les sessions vivent environ 30 minutes.

CrawlbaseAPI-Parameters

query stringoptionnel

L'ensemble complet des paramètres de la Crawling API passé sous forme d'une seule chaîne jointe par des esperluettes. Tout ce que vous ajouteriez à une requête REST — javascript=true, page_wait=2000, scroll=true, store=true, &scraper=amazon-product-details, autoparse=true — fonctionne ici. Combinez-en plusieurs avec & : par exemple "javascript=true&country=US&store=true".

Utiliser CrawlbaseAPI-Parameters

Les en-têtes mono-fonction ci-dessus (Country, Device, Session-Id) sont des raccourcis pour les contrôles les plus courants. Tout le reste de l'ensemble de paramètres de la Crawling API — rendu JS, scroll, click selectors, scrapers, async + webhooks + storage, get_cookies, get_headers — est accessible via l'en-tête CrawlbaseAPI-Parameters. Le format est la même query string que vous ajouteriez à un appel REST :

# JS-rendered SPA, store the result, force US geo
curl -x 'http://YOUR_JS_TOKEN:@smartproxy.crawlbase.com:8012' \
     -H 'CrawlbaseAPI-Parameters: javascript=true&country=US&store=true&page_wait=2000' \
     -k 'https://spa.example.com/feed'

# Apply a scraper — same as &scraper=… on the REST endpoint
curl -x 'http://YOUR_TOKEN:@smartproxy.crawlbase.com:8012' \
     -H 'CrawlbaseAPI-Parameters: scraper=amazon-product-details' \
     -k 'https://www.amazon.com/dp/B0CHX2XFLN'

Résolution des conflits : si vous passez à la fois un en-tête mono-fonction (par exemple CrawlbaseAPI-Country: GB) et le même champ dans CrawlbaseAPI-Parameters, l'en-tête mono-fonction l'emporte. Choisissez un seul style par requête pour garder un comportement prévisible.

# Pin to a US session for a multi-step checkout flow
curl -x 'http://YOUR_TOKEN:@smartproxy.crawlbase.com:8012' \
     -H 'CrawlbaseAPI-Country: US' \
     -H 'CrawlbaseAPI-Session-Id: checkout-user-42' \
     -k 'https://shop.example.com/cart'

Erreurs

Smart Proxy renvoie des réponses HTTP standard. Les codes de statut suivent le même modèle que la Crawling API. Les erreurs d'authentification (401, 402) sont renvoyées par le proxy lui-même ; les erreurs du site (404, 500, etc.) proviennent de la cible.