Proxy Detection Test

import requests

response = requests.get(
    'https://vpnapi.io/api/IP_ADDRESS',
    params={'key': 'YOUR_API_KEY'}
)
data = response.json()

if data['security']['proxy']:
    print('Proxy detected - block or flag this request.')
else:
    print('No proxy detected.')

<?php
$url = 'https://vpnapi.io/api/IP_ADDRESS?key=YOUR_API_KEY';
$response = file_get_contents($url);
$data = json_decode($response, true);

if ($data['security']['proxy']) {
    echo 'Proxy detected - block or flag this request.';
} else {
    echo 'No proxy detected.';
}
?>

package main

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

type Security struct {
    Proxy bool `json:"proxy"`
}

type Response struct {
    Security Security `json:"security"`
}

func main() {
    resp, _ := http.Get("https://vpnapi.io/api/IP_ADDRESS?key=YOUR_API_KEY")
    defer resp.Body.Close()

    var data Response
    json.NewDecoder(resp.Body).Decode(&data)

    if data.Security.Proxy {
        fmt.Println("Proxy detected - block or flag this request.")
    } else {
        fmt.Println("No proxy detected.")
    }
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import org.json.JSONObject;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://vpnapi.io/api/IP_ADDRESS?key=YOUR_API_KEY"))
    .build();

HttpResponse<String> response = client.send(
    request, HttpResponse.BodyHandlers.ofString()
);
JSONObject data = new JSONObject(response.body());
boolean isProxy = data.getJSONObject("security").getBoolean("proxy");

if (isProxy) {
    System.out.println("Proxy detected - block or flag this request.");
} else {
    System.out.println("No proxy detected.");
}

require 'net/http'
require 'json'

uri = URI('https://vpnapi.io/api/IP_ADDRESS?key=YOUR_API_KEY')
response = Net::HTTP.get(uri)
data = JSON.parse(response)

if data['security']['proxy']
  puts 'Proxy detected - block or flag this request.'
else
  puts 'No proxy detected.'
end

use serde::Deserialize;

#[derive(Deserialize)]
struct Security {
    proxy: bool,
}

#[derive(Deserialize)]
struct ApiResponse {
    security: Security,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://vpnapi.io/api/IP_ADDRESS?key=YOUR_API_KEY";
    let data: ApiResponse = reqwest::get(url).await?.json().await?;

    if data.security.proxy {
        println!("Proxy detected - block or flag this request.");
    } else {
        println!("No proxy detected.");
    }
    Ok(())
}

#include <iostream>
#include <curl/curl.h>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

static size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* s) {
    s->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl = curl_easy_init();
    std::string responseBody;

    curl_easy_setopt(curl, CURLOPT_URL,
        "https://vpnapi.io/api/IP_ADDRESS?key=YOUR_API_KEY");
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &responseBody);
    curl_easy_perform(curl);
    curl_easy_cleanup(curl);

    auto data = json::parse(responseBody);
    if (data["security"]["proxy"].get<bool>()) {
        std::cout << "Proxy detected." << std::endl;
    } else {
        std::cout << "No proxy detected." << std::endl;
    }
    return 0;
}

import Foundation

struct Security: Decodable {
    let proxy: Bool
}

struct ApiResponse: Decodable {
    let security: Security
}

let url = URL(string: "https://vpnapi.io/api/IP_ADDRESS?key=YOUR_API_KEY")!
let (data, _) = try await URLSession.shared.data(from: url)
let result = try JSONDecoder().decode(ApiResponse.self, from: data)

if result.security.proxy {
    print("Proxy detected - block or flag this request.")
} else {
    print("No proxy detected.")
}

import java.net.URL
import org.json.JSONObject

fun main() {
    val response = URL("https://vpnapi.io/api/IP_ADDRESS?key=YOUR_API_KEY")
        .readText()
    val data = JSONObject(response)
    val isProxy = data.getJSONObject("security").getBoolean("proxy")

    if (isProxy) {
        println("Proxy detected - block or flag this request.")
    } else {
        println("No proxy detected.")
    }
}

// Next.js API route - backend only (pages/api/check-proxy.js)
// Never call the vpnapi.io API directly from the browser.

export default async function handler(req, res) {
  const { ip } = req.query;

  const response = await fetch(
    `https://vpnapi.io/api/${ip}?key=YOUR_API_KEY`
  );
  const data = await response.json();

  res.status(200).json({
    isProxy: data.security.proxy,
  });
}