PHProxy

Use Via PHProxy to make the request from this proxy server. The destination URL appears in the JSON payload. Direct to destination sends the request from your own computer.

Proxy endpoint: https://proxy.budala.online/index.php?api=fetch
Destination (example): https://example.com/

curl -X POST 'https://proxy.budala.online/index.php?api=fetch' \
  -H 'Content-Type: application/json' \
  -d '{
    "url": "https://example.com/",
    "headers": {
        "User-Agent": "PHProxy/1.4.0"
    }
}' \
  | jq -r .body

curl -X 'GET' 'https://example.com/' \
  -H 'User-Agent: PHProxy/1.4.0'

# IP info — client + server + outgoing IP + reverse DNS + request headers
curl 'https://proxy.budala.online/index.php?api=ipinfo'

# IP info — reverse DNS for any IP (IPv4 or IPv6)
curl 'https://proxy.budala.online/index.php?api=ipinfo&ip=1.1.1.1'

# Port check — single port
curl 'https://proxy.budala.online/index.php?api=portcheck&host=example.com&port=443'

# Port check — inclusive range
curl 'https://proxy.budala.online/index.php?api=portcheck&host=example.com&port=8000-8010'

# Port check — comma-list, mixed with ranges (max 128 ports)
curl 'https://proxy.budala.online/index.php?api=portcheck&host=example.com&port=22,80,443,8000-8010'

# Port check — streaming (NDJSON, one line per port as it completes)
curl -N 'https://proxy.budala.online/index.php?api=portcheck&host=example.com&port=22-30&stream=1'

# DNS lookup — A / AAAA / MX / TXT / NS / SOA / CAA / CNAME / SRV / ANY
curl 'https://proxy.budala.online/index.php?api=dns&host=example.com&type=A'

# SSL handshake + cert chain inspection
curl 'https://proxy.budala.online/index.php?api=cert&host=example.com&port=443'

<?php
$payload = array (
  'url' => 'https://example.com/',
  'headers' => 
  array (
    'User-Agent' => 'PHProxy/1.4.0',
  ),
);

$ch = curl_init('https://proxy.budala.online/index.php?api=fetch');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => json_encode($payload),
    CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
    CURLOPT_RETURNTRANSFER => true,
]);
$envelope = json_decode(curl_exec($ch), true);
curl_close($ch);

echo $envelope['status'], "\n", $envelope['body'];

<?php
$ch = curl_init('https://example.com/');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTPHEADER     => [
        'User-Agent: PHProxy/1.4.0',
    ],
]);
$response = curl_exec($ch);
$status   = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo $status, "\n", $response;

<?php
$base = 'https://proxy.budala.online/index.php';

// IP info — me, the server, the server's outgoing IP + reverse DNS
$ipinfo = json_decode(file_get_contents($base . '?api=ipinfo'), true);
printf("client:   %s   %s\n",   $ipinfo['client']['ip'],   $ipinfo['client']['reverse']   ?? '');
printf("outgoing: %s   %s\n", $ipinfo['outgoing']['ip'], $ipinfo['outgoing']['reverse'] ?? '');

// Port check — accepts: 443  |  8000-8010  |  22,80,443,8000-8010  (max 128)
$port = json_decode(file_get_contents($base . '?api=portcheck&host=example.com&port=8000-8010'), true);
foreach ($port['results'] as $r) {
    printf("%5d  %s  %d ms\n", $r['port'], $r['reachable'] ? 'OPEN  ' : 'CLOSED', $r['latency_ms']);
}

// DNS lookup
$dns = json_decode(file_get_contents($base . '?api=dns&host=example.com&type=A'), true);
print_r($dns);

// SSL cert inspect
$cert = json_decode(file_get_contents($base . '?api=cert&host=example.com&port=443'), true);
print_r($cert);

import requests

payload = {
    "url":    'https://example.com/',
    "headers": {
        'User-Agent': 'PHProxy/1.4.0',
    },
}

envelope = requests.post('https://proxy.budala.online/index.php?api=fetch', json=payload).json()
print(envelope['status'])
print(envelope['body'])

import requests

response = requests.request('GET', 'https://example.com/',
    headers={
        'User-Agent': 'PHProxy/1.4.0',
    },
    allow_redirects=True,
)

print(response.status_code)
print(response.text)

import requests

base = 'https://proxy.budala.online/index.php'

# IP info — me, the server, the server's outgoing IP + reverse DNS
ip = requests.get(base, params={'api': 'ipinfo'}).json()
print(f"client:   {ip['client']['ip']}   {ip['client'].get('reverse','')}")
print(f"outgoing: {ip['outgoing']['ip']}   {ip['outgoing'].get('reverse','')}")

# Port check — accepts: 443  |  8000-8010  |  22,80,443,8000-8010  (max 128)
scan = requests.get(base, params={'api': 'portcheck', 'host': 'example.com', 'port': '8000-8010'}).json()
for r in scan['results']:
    print(f"{r['port']:>5}  {'OPEN  ' if r['reachable'] else 'CLOSED'}  {r['latency_ms']} ms")

# DNS lookup
print(requests.get(base, params={'api': 'dns', 'host': 'example.com', 'type': 'A'}).json())

# SSL cert inspect
print(requests.get(base, params={'api': 'cert', 'host': 'example.com', 'port': 443}).json())

const payload = {
    url: 'https://example.com/',
    headers: {
        'User-Agent': 'PHProxy/1.4.0',
    },
};

const r = await fetch('https://proxy.budala.online/index.php?api=fetch', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(payload),
});
const envelope = await r.json();
console.log(envelope.status, envelope.body);

const response = await fetch('https://example.com/', {
    method: 'GET',
    headers: {
        'User-Agent': 'PHProxy/1.4.0',
    },
});
console.log(response.status, await response.text());

const base = 'https://proxy.budala.online/index.php';

// IP info — me, the server, the server's outgoing IP + reverse DNS
const ip = await fetch(base + '?api=ipinfo').then(r => r.json());
console.log(`client:   ${ip.client.ip}   ${ip.client.reverse ?? ''}`);
console.log(`outgoing: ${ip.outgoing.ip}   ${ip.outgoing.reverse ?? ''}`);

// Port check — accepts: 443  |  8000-8010  |  22,80,443,8000-8010  (max 128)
const scan = await fetch(base + '?api=portcheck&host=example.com&port=8000-8010').then(r => r.json());
for (const r of scan.results) {
    console.log(`${String(r.port).padStart(5)}  ${r.reachable ? 'OPEN  ' : 'CLOSED'}  ${r.latency_ms} ms`);
}

// DNS lookup
const dns = await fetch(base + '?api=dns&host=example.com&type=A').then(r => r.json());
console.log(dns);

// SSL cert inspect
const cert = await fetch(base + '?api=cert&host=example.com&port=443').then(r => r.json());
console.log(cert);

package main

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

func main() {
    payload := map[string]any{
        "url":     "https://example.com/",
        "headers": map[string]string{
            "User-Agent": "PHProxy/1.4.0",
        },
    }
    j, _ := json.Marshal(payload)
    resp, err := http.Post("https://proxy.budala.online/index.php?api=fetch", "application/json", bytes.NewReader(j))
    if err != nil { panic(err) }
    defer resp.Body.Close()

    var envelope struct{ Status int `json:"status"`; Body string `json:"body"` }
    json.NewDecoder(resp.Body).Decode(&envelope)
    fmt.Println(envelope.Status, envelope.Body)
}

package main

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

func main() {
    req, _ := http.NewRequest("GET", "https://example.com/", nil)
    req.Header.Set("User-Agent", "PHProxy/1.4.0")

    resp, err := (&http.Client{}).Do(req)
    if err != nil { panic(err) }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(resp.StatusCode, string(body))
}

package main

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

func get(url string) map[string]any {
    r, _ := http.Get(url)
    defer r.Body.Close()
    b, _ := io.ReadAll(r.Body)
    var m map[string]any
    json.Unmarshal(b, &m)
    return m
}

func main() {
    base := "https://proxy.budala.online/index.php"

    // IP info — me, the server, the server's outgoing IP + reverse DNS
    fmt.Println(get(base + "?api=ipinfo"))

    // Port check — accepts: 443  |  8000-8010  |  22,80,443,8000-8010  (max 128)
    scan := get(base + "?api=portcheck&host=example.com&port=8000-8010")
    for _, r := range scan["results"].([]any) {
        rr := r.(map[string]any)
        status := "CLOSED"
        if rr["reachable"].(bool) { status = "OPEN  " }
        fmt.Printf("%5.0f  %s  %.0f ms\n", rr["port"], status, rr["latency_ms"])
    }

    fmt.Println(get(base + "?api=dns&host=example.com&type=A"))
    fmt.Println(get(base + "?api=cert&host=example.com&port=443"))
}