PHProxy.

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

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

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

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

# Port check — single port
curl 'https://gh.dogstudio.org/index.php?api=portcheck&host=example.com&port=443'

# Port check — inclusive range
curl 'https://gh.dogstudio.org/index.php?api=portcheck&host=example.com&port=80-443'

# Port check — comma-list, mixed with ranges (max 128 ports)
curl 'https://gh.dogstudio.org/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://gh.dogstudio.org/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://gh.dogstudio.org/index.php?api=dns&host=example.com&type=A'

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

<?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.0',
    ],
]);
$response = curl_exec($ch);
$status   = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

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

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

$ch = curl_init('https://gh.dogstudio.org/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
$base = 'https://gh.dogstudio.org/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  |  80-443  |  22,80,443,8000-8010  (max 128)
$port = json_decode(file_get_contents($base . '?api=portcheck&host=example.com&port=80-443'), 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

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

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

import requests

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

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

import requests

base = 'https://gh.dogstudio.org/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  |  80-443  |  22,80,443,8000-8010  (max 128)
scan = requests.get(base, params={'api': 'portcheck', 'host': 'example.com', 'port': '80-443'}).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 response = await fetch('https://example.com/', {
    method: 'GET',
    headers: {
        'User-Agent': 'PHProxy/1.0',
    },
});
console.log(response.status, await response.text());

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

const r = await fetch('https://gh.dogstudio.org/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 base = 'https://gh.dogstudio.org/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  |  80-443  |  22,80,443,8000-8010  (max 128)
const scan = await fetch(base + '?api=portcheck&host=example.com&port=80-443').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 (
    "fmt"
    "io"
    "net/http"
)

func main() {
    req, _ := http.NewRequest("GET", "https://example.com/", nil)
    req.Header.Set("User-Agent", "PHProxy/1.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 (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    payload := map[string]any{
        "url":     "https://example.com/",
        "headers": map[string]string{
            "User-Agent": "PHProxy/1.0",
        },
    }
    j, _ := json.Marshal(payload)
    resp, err := http.Post("https://gh.dogstudio.org/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 (
    "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://gh.dogstudio.org/index.php"

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

    // Port check — accepts: 443  |  80-443  |  22,80,443,8000-8010  (max 128)
    scan := get(base + "?api=portcheck&host=example.com&port=80-443")
    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"))
}