Integraciones de código

El gateway de Shifter habla HTTP(S) plano y SOCKS5 en p.shifter.io:443. Cualquier cliente HTTP(S) en cualquier lenguaje que admita autenticación de proxy funcionará, no se necesita ningún SDK.

El nombre de usuario codifica tus preferencias de segmentación y sesión; la contraseña es la contraseña de tu cuenta. Consulta Gateway & auth para ver la lista completa de indicadores.

Python

La opción más popular es requests con un diccionario de 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)

Para código asíncrono, httpx funciona de la misma forma (httpx.AsyncClient(proxies=proxy)).

Node.js

Usa node-fetch (o el fetch integrado en Node 18+) con 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 y undici aceptan todos una opción de agente similar.

TypeScript

El mismo entorno de ejecución que Node.js, solo que tipado. Ejemplo con 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 puro, sin transpilador:

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);

Go

Biblioteca estándar, sin dependencias de terceros:

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 con autenticación básica en el 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 integrado (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 con 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 con la opción de solicitud 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();

Los enlaces (bindings) planos de curl (curl_setopt($ch, CURLOPT_PROXY, '...')) también funcionan.

¿Necesitas algo más?

El gateway es un proxy HTTP/HTTPS/SOCKS plano. Si tu cliente habla cualquiera de estos protocolos con autenticación básica, funcionará. Para herramientas específicas de producto (Scrapy, Puppeteer, Playwright, SwitchyOmega, Multilogin), consulta Residential Proxies → Integrations.

Comenzar

Proxies

APIs

Recursos