Intégrations de code

La passerelle Shifter parle HTTP(S) et SOCKS5 en clair sur p.shifter.io:443. Tout client HTTP(S) dans n’importe quel langage prenant en charge l’authentification par proxy fonctionnera, aucun SDK n’est requis.

Le nom d’utilisateur encode votre ciblage et vos préférences de session ; le mot de passe est celui de votre compte. Consultez Gateway & auth pour la liste complète des indicateurs.

Astuce

Remplacez USERNAME et PASSWORD par les identifiants de votre panel. Ajoutez -region-<slug>, -city-<slug>, -asn-<num>, -sid-<id> (avec en option -ttl-<seconds>), ou -strict-true au nom d’utilisateur pour un contrôle plus fin.

Python

L’option la plus populaire est requests avec un dictionnaire proxies :

import requests

proxy = "customer-USERNAME-country-us-sid-9f3a2b7c-ttl-600:PASSWORD@p.shifter.io:443"
proxies = {"http": proxy, "https": proxy}

r = requests.get("https://ipinfo.io/json", proxies=proxies)
print(r.text)

Pour du code asynchrone, httpx fonctionne de la même manière (httpx.AsyncClient(proxies=proxy)).

Node.js

Utilisez node-fetch (ou le fetch intégré dans Node 18+) avec https-proxy-agent :

import fetch from 'node-fetch';
import { HttpsProxyAgent } from 'https-proxy-agent';

const agent = new HttpsProxyAgent(
  'customer-USERNAME-country-us-sid-9f3a2b7c-ttl-600:PASSWORD@p.shifter.io:443'
);

const res = await fetch('https://ipinfo.io/json', { agent });
console.log(await res.text());

axios, got, et undici acceptent tous une option d’agent similaire.

TypeScript

Même environnement d’exécution que Node.js, simplement typé. Exemple avec axios :

import axios from 'axios';
import { HttpsProxyAgent } from 'https-proxy-agent';

const agent = new HttpsProxyAgent(
  'customer-USERNAME-country-us-sid-9f3a2b7c-ttl-600:PASSWORD@p.shifter.io:443'
);

const { data } = await axios.get<string>('https://ipinfo.io/json', {
  httpAgent: agent,
  httpsAgent: agent,
});

console.log(data);

JavaScript

Node CommonJS simple, sans transpileur :

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

const agent = new HttpsProxyAgent(
  'customer-USERNAME-country-us-sid-9f3a2b7c-ttl-600:PASSWORD@p.shifter.io:443'
);

fetch('https://ipinfo.io/json', { agent })
  .then((r) => r.text())
  .then(console.log);

Attention

Le JavaScript côté navigateur ne peut pas configurer de proxys HTTP. Faites transiter les requêtes par un backend Node, Cloudflare Workers, ou une fonction serverless qui utilise la passerelle.

Go

Bibliothèque standard, aucune dépendance tierce :

package main

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

func main() {
  proxyURL, _ := url.Parse("customer-USERNAME-country-us-sid-9f3a2b7c-ttl-600:PASSWORD@p.shifter.io:443")
  client := &http.Client{
    Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
  }

  resp, _ := client.Get("https://ipinfo.io/json")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

Rust

reqwest avec authentification de base sur le proxy :

use reqwest::blocking::Client;
use reqwest::Proxy;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let proxy = Proxy::all("http://p.shifter.io:443")?
        .basic_auth("customer-USERNAME-country-us-sid-9f3a2b7c-ttl-600", "PASSWORD");

    let client = Client::builder().proxy(proxy).build()?;
    let body = client.get("https://ipinfo.io/json").send()?.text()?;
    println!("{body}");
    Ok(())
}

Java

java.net.http.HttpClient intégré (Java 11+) :

import java.net.*;
import java.net.http.*;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .proxy(ProxySelector.of(new InetSocketAddress("p.shifter.io", 443)))
            .authenticator(new Authenticator() {
                protected PasswordAuthentication getPasswordAuthentication() {
                    return new PasswordAuthentication(
                        "customer-USERNAME-country-us-sid-9f3a2b7c-ttl-600",
                        "PASSWORD".toCharArray()
                    );
                }
            })
            .build();

        HttpRequest req = HttpRequest.newBuilder(URI.create("https://ipinfo.io/json")).build();
        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}

C#

HttpClient avec HttpClientHandler.Proxy :

using System.Net;
using System.Net.Http;

var handler = new HttpClientHandler
{
    Proxy = new WebProxy("http://p.shifter.io:443")
    {
        Credentials = new NetworkCredential(
            "customer-USERNAME-country-us-sid-9f3a2b7c-ttl-600",
            "PASSWORD"
        )
    },
    UseProxy = true
};

using var client = new HttpClient(handler);
var ip = await client.GetStringAsync("https://ipinfo.io/json");
Console.WriteLine(ip);

PHP

Guzzle avec l’option de requête proxy :

<?php
require 'vendor/autoload.php';

$client = new GuzzleHttp\Client([
    'proxy' => 'customer-USERNAME-country-us-sid-9f3a2b7c-ttl-600:PASSWORD@p.shifter.io:443',
]);

$res = $client->get('https://ipinfo.io/json');
echo $res->getBody();

Les liaisons curl classiques (curl_setopt($ch, CURLOPT_PROXY, '...')) fonctionnent également.

Besoin d’autre chose ?

La passerelle est un simple proxy HTTP/HTTPS/SOCKS. Si votre client prend en charge l’un de ces protocoles avec authentification de base, cela fonctionne. Pour des outils spécifiques à des produits (Scrapy, Puppeteer, Playwright, SwitchyOmega, Multilogin), consultez Residential Proxies → Integrations.