Más IP únicas que cualquier red del planeta, en el mayor pool residencial del mundo. Eso es Shifter.Más IP únicas que cualquier red, en el mayor pool del mundo. Eso es Shifter.

Ver los números
Integración

Usa Shifter con Java

Integra los proxies residenciales y de ISP de Shifter en aplicaciones Java en minutos. Compatible con el HttpClient integrado (Java 11+), OkHttp, Apache HttpClient, Selenium y Jsoup, sin necesidad de SDK.

Inicio rápido

Instalar

// Maven
// <dependency><groupId>com.squareup.okhttp3</groupId><artifactId>okhttp</artifactId><version>4.12.0</version></dependency>

Uso básico

import java.net.*;
import java.net.http.*;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Quickstart {
  public static void main(String[] args) throws Exception {
    Authenticator auth = new Authenticator() {
      @Override
      protected PasswordAuthentication getPasswordAuthentication() {
        return new PasswordAuthentication(
          "customer-USERNAME-country-us-sid-123ABC",
          "PASSWORD".toCharArray());
      }
    };

    HttpClient client = HttpClient.newBuilder()
      .proxy(ProxySelector.of(new InetSocketAddress("p.shifter.io", 443)))
      .authenticator(auth)
      .build();

    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("http://ip-info.com/json"))
      .GET()
      .build();

    HttpResponse<String> response =
      client.send(request, HttpResponse.BodyHandlers.ofString());

    System.out.println(response.body());
  }
}

Características

Compatibilidad directa con HttpClient (Java 11+), OkHttp, Apache HttpClient, RestTemplate y WebClient
Rotación por solicitud de forma predeterminada, con `sid` para sesiones persistentes y `ttl-N` para fijar IPs durante N segundos
Compatibilidad con navegadores headless mediante Selenium WebDriver y Playwright para Java
Protocolos HTTP, HTTPS y SOCKS5 en el mismo endpoint de pasarela
Geolocalización en más de 195 países mediante parámetros de usuario, sin necesidad de ninguna dependencia adicional
Compatible con Java 8, 11, 17 y 21, y funciona con Maven, Gradle y cualquier ecosistema JVM (Kotlin, Scala, Groovy)

Ejemplos

HttpClient integrado (Java 11+)

La biblioteca estándar desde Java 11, sin dependencias de terceros. Configura el proxy mediante ProxySelector y las credenciales mediante Authenticator. El mismo cliente es seguro para compartir entre hilos.

import java.net.*;
import java.net.http.*;
import java.time.Duration;

public class HttpClientExample {
  static final String PROXY_HOST = "p.shifter.io";
  static final int    PROXY_PORT = 443;

  static HttpClient client(String country, String sid) {
    Authenticator auth = new Authenticator() {
      @Override
      protected PasswordAuthentication getPasswordAuthentication() {
        return new PasswordAuthentication(
          String.format("customer-USERNAME-country-%s-sid-%s-ttl-300", country, sid),
          "PASSWORD".toCharArray());
      }
    };

    return HttpClient.newBuilder()
      .proxy(ProxySelector.of(new InetSocketAddress(PROXY_HOST, PROXY_PORT)))
      .authenticator(auth)
      .connectTimeout(Duration.ofSeconds(10))
      .build();
  }

  public static void main(String[] args) throws Exception {
    HttpClient c = client("uk", "456DEF");

    for (String path : new String[]{"/login", "/dashboard", "/orders"}) {
      HttpRequest req = HttpRequest.newBuilder()
        .uri(URI.create("https://example.co.uk" + path))
        .header("User-Agent", "Mozilla/5.0 (Windows) AppleWebKit/537.36")
        .timeout(Duration.ofSeconds(30))
        .GET()
        .build();

      HttpResponse<String> r = c.send(req, HttpResponse.BodyHandlers.ofString());
      System.out.println(path + " " + r.statusCode() + " " + r.body().length());
    }
  }
}

OkHttp

OkHttp es el cliente HTTP más popular en Java. Configura el proxy y las credenciales en el constructor del cliente: el mismo cliente puede reutilizarse de forma segura entre hilos y multiplexa conexiones.

import okhttp3.*;
import java.net.InetSocketAddress;
import java.net.Proxy;

public class OkHttpExample {
  public static void main(String[] args) throws Exception {
    Proxy proxy = new Proxy(Proxy.Type.HTTP,
      new InetSocketAddress("p.shifter.io", 443));

    Authenticator proxyAuth = (route, response) -> {
      String credential = Credentials.basic(
        "customer-USERNAME-country-de-city-berlin-sid-789GHI", "PASSWORD");
      return response.request().newBuilder()
        .header("Proxy-Authorization", credential)
        .build();
    };

    OkHttpClient client = new OkHttpClient.Builder()
      .proxy(proxy)
      .proxyAuthenticator(proxyAuth)
      .build();

    Request request = new Request.Builder()
      .url("https://api.example.de/products")
      .header("User-Agent", "Mozilla/5.0 (Linux) AppleWebKit/537.36")
      .build();

    try (Response response = client.newCall(request).execute()) {
      System.out.println(response.code() + " " + response.body().string().length());
    }
  }
}

Selenium WebDriver

Controla una instancia real de Chrome o Firefox a través de Shifter para objetivos con JavaScript renderizado. Usa selenium-wire (o una extensión de Chrome) para gestionar la autenticación del proxy.

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.Proxy;

public class SeleniumExample {
  public static void main(String[] args) {
    Proxy proxy = new Proxy();
    proxy.setHttpProxy("p.shifter.io:443");
    proxy.setSslProxy("p.shifter.io:443");

    ChromeOptions options = new ChromeOptions();
    options.setProxy(proxy);
    options.addArguments("--headless=new");
    options.addArguments(
      "--user-agent=Mozilla/5.0 (Macintosh) AppleWebKit/537.36"
    );

    // For username-password proxy auth, pair this with Shifter's IP
    // whitelist or use selenium-wire — Chrome ignores credentials in
    // headless mode without a sidecar extension.

    WebDriver driver = new ChromeDriver(options);
    try {
      driver.get("https://example.com");
      System.out.println(driver.getTitle());
      System.out.println(driver.getPageSource().length() + " bytes");
    } finally {
      driver.quit();
    }
  }
}

Spring Boot RestTemplate / WebClient

Envuelve Shifter en una @Configuration de Spring para que cada RestTemplate o WebClient que inyecte tu aplicación enrute a través del proxy. Compatible con Spring 5+ y Spring Boot 3.

import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.HttpHost;
import org.apache.hc.client5.http.auth.*;
import org.apache.hc.client5.http.impl.auth.BasicCredentialsProvider;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ShifterRestConfig {
  @Bean
  public RestTemplate shifterRestTemplate() {
    HttpHost proxy = new HttpHost("http", "p.shifter.io", 443);

    BasicCredentialsProvider creds = new BasicCredentialsProvider();
    creds.setCredentials(
      new AuthScope(proxy),
      new UsernamePasswordCredentials(
        "customer-USERNAME-country-fr-sid-ABC123",
        "PASSWORD".toCharArray()));

    CloseableHttpClient httpClient = HttpClients.custom()
      .setProxy(proxy)
      .setDefaultCredentialsProvider(creds)
      .setDefaultRequestConfig(RequestConfig.custom().build())
      .build();

    HttpComponentsClientHttpRequestFactory factory =
      new HttpComponentsClientHttpRequestFactory(httpClient);

    return new RestTemplate(factory);
  }
}
Preguntas frecuentes

Preguntas frecuentes

Preguntas frecuentes sobre el uso de Shifter con Java.

Pasa ProxySelector.of(new InetSocketAddress("p.shifter.io", 443)) a HttpClient.newBuilder().proxy(...) y proporciona credenciales mediante un Authenticator que devuelva PasswordAuthentication en getPasswordAuthentication. Solo biblioteca estándar -- sin dependencias adicionales.

Establece el proxy en OkHttpClient.Builder() con new Proxy(Proxy.Type.HTTP, address) y proporciona un proxyAuthenticator que añada una cabecera Proxy-Authorization usando Credentials.basic(user, pass). El mismo cliente puede reutilizarse de forma segura entre hilos.

Sí. Establece el host del proxy HTTP y SSL en un objeto Selenium Proxy, adjúntalo a ChromeOptions y lanza ChromeDriver. Para la autenticación con usuario y contraseña en modo headless, combínalo con la lista blanca de IPs de Shifter o usa selenium-wire, ya que Chrome no solicita credenciales de proxy de forma nativa.

Añade un ID de sesión al nombre de usuario del proxy, por ejemplo `customer-USERNAME-country-us-sid-123ABC`. Cada solicitud que se autentique con el mismo sid reutilizará la misma IP residencial. Añade `ttl-N` para fijar esa IP durante un máximo de N segundos.

Sí. Configura un @Bean de RestTemplate o WebClient que envuelva un Apache HttpClient o un cliente Reactor Netty con Shifter como proxy. Inyecta ese bean donde necesites llamar a APIs externas: compatible con Spring Framework 5+ y Spring Boot 3.

No se necesita ningún SDK. Shifter utiliza HTTP y SOCKS5 estándar: apunta tu cliente existente a `p.shifter.io:443`. Esto mantiene tu pom.xml o build.gradle ligero y funciona con Java 8 hasta Java 21.

Comenzar

Empieza a usar Shifter con Java

Añade los más de 205M+ proxies residenciales y de ISP de Shifter a tu stack JVM en menos de 5 minutos. Compatible con HttpClient, OkHttp, Spring y Selenium WebDriver.

Configuración en minutos. Cancela cuando quieras.