Smart AI Proxy · Documentation Crawlbase

Point de terminaison

HTTPSsmartproxy.crawlbase.com:8013

HTTPsmartproxy.crawlbase.com:8012

Préférez le proxy HTTPS sur le port 8013 (recommandé). Le proxy HTTP sur le port 8012 est disponible pour les clients qui ne communiquent qu'en HTTP avec les proxies en amont.
Authentifiez-vous avec votre token comme nom d'utilisateur ; laissez le mot de passe vide.
Les deux ports fonctionnent avec n'importe quelle URL cible, en HTTP ou en HTTPS.

Démarrage rapide

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

Désactiver la vérification TLS

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

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

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

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

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', 8013, '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("https://YOUR_TOKEN:@smartproxy.crawlbase.com:8013")
    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))
}

Requêtes POST

Smart AI Proxy transmet les requêtes POST à la cible comme toute autre méthode HTTP. Définissez le proxy sur votre client et faites un POST comme vous le feriez normalement : 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 par les clients : form-encoded et JSON.

Body form-encoded

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

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

proxies = {
    'http':  'https://YOUR_TOKEN:@smartproxy.crawlbase.com:8013',
    'https': 'https://YOUR_TOKEN:@smartproxy.crawlbase.com:8013',
}
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(
  'https://YOUR_TOKEN:@smartproxy.crawlbase.com:8013'
);
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', 8013, '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("https://[email protected]:8013")
    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 'https://[email protected]:8013' \
     -k 'https://httpbin.org/anything'

import requests
proxies = {
    'http':  'https://YOUR_TOKEN:@smartproxy.crawlbase.com:8013',
    'https': 'https://YOUR_TOKEN:@smartproxy.crawlbase.com:8013',
}
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(
  'https://YOUR_TOKEN:@smartproxy.crawlbase.com:8013'
);
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', 8013, '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 AI Proxy transmet la plupart des en-têtes et cookies de votre requête sortante vers la cible, afin que les clients existants continuent de fonctionner sans modification. Deux comportements à noter :

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 du proxy (Host, Proxy-Authorization) sont supprimés : ils décrivent le proxy lui-même, et non 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 'https://[email protected]:8013' \
     -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 modifier le comportement du proxy (pays, appareil, 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 AI Proxy s'appuie sur la même flotte de navigateurs headless que la Crawling API. Pour exécuter du JavaScript, capturer des SPA rendues côté client, ou appliquer des fonctionnalités de la Crawling API qui nécessitent un vrai navigateur (captures d'écran, scroll, click-selectors, autoparse), passez CrawlbaseAPI-Parameters: javascript=true en tant qu'en-tête sur 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 'https://[email protected]:8013' \
     -k 'https://spa.example.com/feed'

Utilisez votre JavaScript token (pas 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 AI Proxy plutôt que la Crawling API

Smart AI Proxy et la Crawling API s'exécutent sur le même réseau et exposent les mêmes fonctionnalités : rendu JS, contournement anti-bot, routage par pays, émulation d'appareil, sessions, scrapers, async + stockage, 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 niveau de concurrence que cet abonnement vous offre.

Choisissez Smart AI 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 AI Proxy, avec son propre niveau 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 AI Proxy via l'en-tête CrawlbaseAPI-Parameters (voir ci-dessous). Les fonctionnalités sont identiques : 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 à usage unique ci-dessus (Country, Device, Session-Id) sont des raccourcis pour les contrôles les plus courants. Tout le reste des paramètres de la Crawling API : rendu JS, scroll, sélecteurs de clic, scrapers, async + webhooks + stockage, get_cookies, get_headers, est accessible via l'en-tête CrawlbaseAPI-Parameters. Le format est la même chaîne de requête que vous ajouteriez à un appel REST :

# JS-rendered SPA, store the result, force US geo
curl -x 'https://YOUR_JS_TOKEN:@smartproxy.crawlbase.com:8013' \
     -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 'https://YOUR_TOKEN:@smartproxy.crawlbase.com:8013' \
     -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 'https://YOUR_TOKEN:@smartproxy.crawlbase.com:8013' \
     -H 'CrawlbaseAPI-Country: US' \
     -H 'CrawlbaseAPI-Session-Id: checkout-user-42' \
     -k 'https://shop.example.com/cart'

Erreurs

Smart AI Proxy retourne 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 retournées par le proxy lui-même ; les erreurs du site (404, 500, etc.) proviennent de la cible.