Un servicio proxy, infinitas soluciones a precios imbatibles.

import requests
username = 'username'
password = 'password'
host = 'gw-us.nstproxy.com'
port = '24125'
proxy = f'http://{username}:{password}@{host}:{port}'
proxy_dict = {
  "http": proxy,
  "https": proxy
}
response = requests.get("API_URL", proxies=proxy_dict)
print(response.text)

const axios = require('axios');

const url = 'API_URL';
axios
  .get(url, {
    proxy: {
      protocol: 'http',
      host: 'gw-us.nstproxy.com',
      port: 24125,
      auth: {
        username: 'username',
        password: 'password',
      },
    },
  })
  .then(res => {
    console.log(res.data);
  })
  .catch(err => {
    console.log('[err]:', err);
  });

package main

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

func main() {
    username := "username"
    password := "password"
    host := "gw-us.nstproxy.com"
    port := 24125
    proxyURL := fmt.Sprintf("http://%s:%s@%s:%v", username, password, host, port)
    proxy, _ := url.Parse(proxyURL)
    client := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxy),
        },
    }

    req, err := http.NewRequest("GET", "API_URL", nil)
    if err != nil {
        panic(err)
    }

    response, err := client.Do(req)

    if err != nil {
        panic(err)
    }
    defer response.Body.Close()

    body, err := ioutil.ReadAll(response.Body)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(body))
}

<?php
$username = 'USERNAME';
$password = 'PASSWORD';
$proxy = 'gw-us.nstproxy.com:24125';
$query = curl_init('API_URL');
curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");
$output = curl_exec($query);
curl_close($query);
if ($output)
    echo $output;
?>

package example;

import org.apache.http.HttpHost;
import org.apache.http.client.fluent.*;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpHost entry = new HttpHost("gw-us.nstproxy.com", 24125);
        String query = Executor.newInstance()
            .auth(entry, "username", "password")
            .execute(Request.Get("API_URL").viaProxy(entry))
            .returnContent().asString();
        System.out.println(query);
    }
}

require "uri"
require 'net/http'

proxy_host = 'gw-us.nstproxy.com'
proxy_port = 24125
proxy_user = 'username'
proxy_pass = 'password'

uri = URI.parse('API_URL')
proxy = Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_pass)

req = Net::HTTP::Get.new(uri.path)

result = proxy.start(uri.host, uri.port) do |http|
   http.request(req)
end

puts result.body

#[tokio::main]
async fn main() {

    let http_proxy = reqwest::Proxy::http("http://gw-us.nstproxy.com:24125")
        .unwrap().basic_auth("user", "password");

    let client = reqwest::ClientBuilder::new().proxy(http_proxy).build().unwrap();

    let resp = client.get("API_URL").send().await.unwrap();

    println!("{:?}", resp.text().await.unwrap());

}