Proxies para Verificação de Anúncios

!import requests

login = 'your_login'
password = 'your_password'
hostname = 'gw.dataimpulse.com'
port = 823

proxies = {
    'http': f'http://{login}:{password}@{hostname}:{port}',
    'https': f'http://{login}:{password}@{hostname}:{port}'
}

try:
    response = requests.get('http://ip-api.com/json', proxies=proxies, timeout=30)
    response.raise_for_status()
    data = response.json()

    print(f"IP address: {data['query']}")
    print(f"Country: {data['country']}")
    print(f"State: {data['regionName']}")
    print(f"City: {data['city']}")
    print(f"Zipcode: {data['zip']}")
    print(f"ASN: {data['as']}")
    print(f"Status: {data['status']}")

except requests.exceptions.RequestException as e:
    print(f"Error: {e}")

const axios = require('axios');

const login = 'your_login';
const password = 'your_password';
const hostname = 'gw.dataimpulse.com';
const port = 823;

const proxyUrl = `http://${login}:${password}@${hostname}:${port}`;

axios.get('http://ip-api.com/json', {
    proxy: {
        host: hostname,
        port: port,
        auth: {
            username: login,
            password: password
        }
    }
})
.then(response => {
    const data = response.data;
    console.log(`IP address: ${data.query}`);
    console.log(`Country: ${data.country}`);
    console.log(`State: ${data.regionName}`);
    console.log(`City: ${data.city}`);
    console.log(`Zipcode: ${data.zip}`);
    console.log(`ASN: ${data.as}`);
    console.log(`Status: ${data.status}`);
})
.catch(error => {
    console.error(`Error: ${error.message}`);
});

$login = 'your_login';
$password = 'your_password';
$hostname = 'gw.dataimpulse.com';
$port = 823;

$proxy = "$hostname:$port";
$proxy_auth = "$login:$password";

$ch = curl_init('http://ip-api.com/json');
curl_setopt($ch, CURLOPT_PROXY, $proxy);
curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxy_auth);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 30);

$response = curl_exec($ch);

if (curl_errno($ch)) {
    echo 'Error: ' . curl_error($ch);
} else {
    $data = json_decode($response, true);
    echo "IP address: " . $data['query'] . "\n";
    echo "Country: " . $data['country'] . "\n";
    echo "State: " . $data['regionName'] . "\n";
    echo "City: " . $data['city'] . "\n";
    echo "Zipcode: " . $data['zip'] . "\n";
    echo "ASN: " . $data['as'] . "\n";
    echo "Status: " . $data['status'] . "\n";
}

curl_close($ch);

using System;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;

class Program
{
    static async Task Main(string[] args)
    {
        var login = "your_login";
        var password = "your_password";
        var hostname = "gw.dataimpulse.com";
        var port = 823;

        var proxy = new WebProxy
        {
            Address = new Uri($"http://{hostname}:{port}"),
            BypassProxyOnLocal = false,
            UseDefaultCredentials = false,
            Credentials = new NetworkCredential(login, password)
        };

        var httpClientHandler = new HttpClientHandler { Proxy = proxy };
        using var client = new HttpClient(httpClientHandler);

        try
        {
            var response = await client.GetStringAsync("http://ip-api.com/json");
            var data = JObject.Parse(response);

            Console.WriteLine($"IP address: {data["query"]}");
            Console.WriteLine($"Country: {data["country"]}");
            Console.WriteLine($"State: {data["regionName"]}");
            Console.WriteLine($"City: {data["city"]}");
            Console.WriteLine($"Zipcode: {data["zip"]}");
            Console.WriteLine($"ASN: {data["as"]}");
            Console.WriteLine($"Status: {data["status"]}");
        }
        catch (Exception e)
        {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"time"
)

func main() {
	login := "your_login"
	password := "your_password"
	hostname := "gw.dataimpulse.com"
	port := "823"

	proxyURL, _ := url.Parse(fmt.Sprintf("http://%s:%s@%s:%s", login, password, hostname, port))
	client := &http.Client{
		Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
		Timeout:   30 * time.Second,
	}

	resp, err := client.Get("http://ip-api.com/json")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		fmt.Println("HTTP error:", resp.Status)
		return
	}

	var data map[string]interface{}

	err = json.NewDecoder(resp.Body).Decode(&data)
	if err != nil {
		fmt.Println("JSON decode error:", err)
		return
	}

	fmt.Printf("IP address: %v\n", data["query"])
	fmt.Printf("Country: %v\n", data["country"])
	fmt.Printf("State: %v\n", data["regionName"])
	fmt.Printf("City: %v\n", data["city"])
	fmt.Printf("Zipcode: %v\n", data["zip"])
	fmt.Printf("ASN: %v\n", data["as"])
	fmt.Printf("Status: %v\n", data["status"])
}

require 'net/http'
require 'json'
require 'uri'

login = 'your_login'
password = 'your_password'
hostname = 'gw.dataimpulse.com'
port = 823

url = URI('http://ip-api.com/json')

http = Net::HTTP::Proxy(hostname, port, login, password).new(url.host, url.port)
http.open_timeout = 30
http.read_timeout = 30

request = Net::HTTP::Get.new(url)

begin
  response = http.request(request)

  unless response.is_a?(Net::HTTPSuccess)
    puts "Error: HTTP #{response.code}"
    exit
  end

  data = JSON.parse(response.body)

  puts "IP address: #{data['query']}"
  puts "Country: #{data['country']}"
  puts "State: #{data['regionName']}"
  puts "City: #{data['city']}"
  puts "Zipcode: #{data['zip']}"
  puts "ASN: #{data['as']}"
  puts "Status: #{data['status']}"

rescue => e
  puts "Error: #{e.message}"
end

curl -s -x http://login:[email protected]:823 http://ip-api.com/json | jq -r '
"IP address: \(.query)
Country: \(.country)
State: \(.regionName)
City: \(.city)
Zipcode: \(.zip)
ASN: \(.as)
Status: \(.status)"
'