Iniciar Teste GratuitoEntrar
Integração

Use a Shifter com Java

Conecte os proxies residenciais e ISP da Shifter a aplicações Java em minutos. Funciona com o HttpClient embutido (Java 11+), OkHttp, Apache HttpClient, Selenium e Jsoup, sem necessidade de SDK.

Início 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("https://ipinfo.io/json"))
      .GET()
      .build();

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

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

Recursos

Suporte plug-and-play para HttpClient (Java 11+), OkHttp, Apache HttpClient, RestTemplate e WebClient
Rotação por requisição por padrão, com `sid` para sessões persistentes e `ttl-N` para fixações por tempo de N segundos
Suporte a navegador headless via Selenium WebDriver e Playwright para Java
Protocolos HTTP, HTTPS e SOCKS5 no mesmo endpoint de gateway
Geo-direcionamento em 195+ países via parâmetros de nome de usuário, sem necessidade de dependência adicional
Compatível com Java 8, 11, 17 e 21; funciona com Maven, Gradle e qualquer ecossistema JVM (Kotlin, Scala, Groovy)

Exemplos

HttpClient integrado (Java 11+)

A biblioteca padrão desde o Java 11, sem dependências de terceiros. Configure o proxy por meio do ProxySelector e as credenciais por meio do Authenticator. O mesmo cliente pode ser compartilhado com segurança entre threads.

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

O OkHttp é o cliente HTTP mais popular em Java. Configure o proxy e as credenciais no client builder, o mesmo cliente pode ser reutilizado com segurança entre threads e multiplexa conexões.

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

Execute uma instância real de Chrome / Firefox através do Shifter para alvos renderizados em JavaScript. Use selenium-wire (ou uma extensão do Chrome) para lidar com a autenticação de 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

Envolva a Shifter em uma @Configuration do Spring para que todo RestTemplate ou WebClient injetado pela sua aplicação passe pelo proxy. Funciona com Spring 5+ e 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);
  }
}
Perguntas Frequentes

Perguntas frequentes

Perguntas comuns sobre usar o Shifter com Java.

Passe ProxySelector.of(new InetSocketAddress("p.shifter.io", 443)) para HttpClient.newBuilder().proxy(...) e forneça as credenciais via um Authenticator que retorna PasswordAuthentication para getPasswordAuthentication. Apenas biblioteca padrão — nenhuma dependência extra.

Defina o proxy no OkHttpClient.Builder() com new Proxy(Proxy.Type.HTTP, address) e forneça um proxyAuthenticator que adicione um cabeçalho Proxy-Authorization usando Credentials.basic(user, pass). O mesmo client pode ser reutilizado com segurança entre threads.

Sim. Defina o host de proxy HTTP e SSL em um objeto Proxy do Selenium, anexe-o ao ChromeOptions e inicie o ChromeDriver. Para autenticação com usuário e senha em modo headless, combine com a whitelist de IP da Shifter ou use selenium-wire, o Chrome não solicita credenciais de proxy nativamente.

Adicione um ID de sessão ao nome de usuário do proxy, por exemplo, `customer-USERNAME-country-us-sid-123ABC`. Toda requisição que autenticar com o mesmo sid reutilizará o mesmo IP residencial. Adicione `ttl-N` para fixar esse IP por até N segundos.

Sim. Configure um @Bean RestTemplate ou WebClient que envolva um cliente Apache HttpClient ou Reactor Netty com o Shifter como proxy. Injete esse bean onde precisar chamar APIs externas — funciona com Spring Framework 5+ e Spring Boot 3.

Nenhum SDK é necessário. A Shifter fala HTTP / SOCKS5 puro, aponte seu cliente existente para `p.shifter.io:443`. Isso mantém seu pom.xml ou build.gradle enxuto e funciona com Java 8 até Java 21.
Começar

Comece a Usar o Shifter com Java

Adicione os proxies residenciais e ISP 205M+ da Shifter à sua stack JVM em menos de 5 minutos. Funciona com HttpClient, OkHttp, Spring e Selenium WebDriver.

Experimente o Shifter GratuitamenteConfigure em minutos. Cancele quando quiser.