API Reference

# Via header (recommended)
curl -H "X-API-Key: as_YOUR_KEY" \
     -H "Content-Type: application/json" \
     -d '{"ip":"1.2.3.4"}' \
     https://analytico.space/api/check.php

# Via body
curl -X POST https://analytico.space/api/check.php \
     -H "Content-Type: application/json" \
     -d '{"api_key":"as_YOUR_KEY","ip":"1.2.3.4"}'

curl -X POST https://analytico.space/api/check.php \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "as_YOUR_KEY",
    "ip": "1.2.3.4",
    "user_agent": "Mozilla/5.0 ...",
    "url": "https://yoursite.com/landing"
  }'

{
  "verdict": "clean",
  "fraud_score": 12,
  "quality_score": 88,
  "is_bot": false,
  "is_vpn": false,
  "country_code": "US",
  "ip_type": "residential"
}

curl -X POST https://analytico.space/api/batch.php \
  -H "X-API-Key: as_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "ips": [
      "1.2.3.4",
      "185.220.101.42",
      "8.8.8.8"
    ]
  }'

{
  "results": [
    {
      "ip": "1.2.3.4",
      "verdict": "clean",
      "fraud_score": 5,
      "quality_score": 95,
      "is_bot": false
    },
    {
      "ip": "185.220.101.42",
      "verdict": "blocked",
      "fraud_score": 97,
      "quality_score": 3,
      "is_bot": true
    }
  ],
  "total": 3,
  "blocked": 1,
  "clean": 2,
  "processing_ms": 142
}

curl https://analytico.space/api/keys.php \
  -H "X-API-Key: as_YOUR_KEY"

{
  "keys": [
    {
      "id": 1,
      "name": "Production key",
      "prefix": "as_prod_****",
      "created_at": "2024-01-15T10:30:00Z",
      "last_used_at": "2024-03-01T14:22:11Z",
      "is_active": true
    }
  ],
  "total": 1
}

class AnalyticoClient {
    private string $apiKey;
    private string $baseUrl = 'https://analytico.space/api';

    public function __construct(string $apiKey) {
        $this->apiKey = $apiKey;
    }

    public function check(string $ip, array $opts = []): array {
        $payload = array_merge(['ip' => $ip], $opts);
        $ch = curl_init($this->baseUrl . '/check.php');
        curl_setopt_array($ch, [
            CURLOPT_POST           => true,
            CURLOPT_POSTFIELDS     => json_encode($payload),
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER     => [
                'Content-Type: application/json',
                'X-API-Key: ' . $this->apiKey,
            ],
            CURLOPT_TIMEOUT        => 5,
        ]);
        $resp = json_decode(curl_exec($ch), true);
        curl_close($ch);
        return $resp ?? [];
    }

    public function batch(array $ips): array {
        $ch = curl_init($this->baseUrl . '/batch.php');
        curl_setopt_array($ch, [
            CURLOPT_POST           => true,
            CURLOPT_POSTFIELDS     => json_encode(['ips' => $ips]),
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER     => [
                'Content-Type: application/json',
                'X-API-Key: ' . $this->apiKey,
            ],
            CURLOPT_TIMEOUT        => 15,
        ]);
        $resp = json_decode(curl_exec($ch), true);
        curl_close($ch);
        return $resp ?? [];
    }
}

# Usage
$client = new AnalyticoClient('as_YOUR_KEY');
$result = $client->check($_SERVER['REMOTE_ADDR']);
if ($result['verdict'] === 'blocked') {
    http_response_code(403); exit;
}

import urllib.request, json

class AnalyticoClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = 'https://analytico.space/api'

    def _post(self, endpoint: str, payload: dict) -> dict:
        data = json.dumps(payload).encode('utf-8')
        req  = urllib.request.Request(
            self.base_url + endpoint,
            data=data,
            headers={
                'Content-Type': 'application/json',
                'X-API-Key': self.api_key,
            }
        )
        with urllib.request.urlopen(req, timeout=5) as r:
            return json.loads(r.read())

    def check(self, ip: str, **kwargs) -> dict:
        """Check a single IP address."""
        return self._post('/check.php', {'ip': ip, **kwargs})

    def batch(self, ips: list) -> dict:
        """Check up to 100 IPs in one request."""
        return self._post('/batch.php', {'ips': ips})

# Usage
client = AnalyticoClient('as_YOUR_KEY')

# Single check
result = client.check('1.2.3.4', user_agent='Mozilla/5.0')
print(result['verdict'], result['fraud_score'])

# Batch check
results = client.batch(['1.2.3.4', '185.220.101.42', '8.8.8.8'])
for r in results['results']:
    if r['verdict'] == 'blocked':
        print(f"Block: {r['ip']}")

class AnalyticoClient {
  constructor(apiKey) {
    this.apiKey  = apiKey;
    this.baseUrl = 'https://analytico.space/api';
  }

  async #post(endpoint, body) {
    const res = await fetch(this.baseUrl + endpoint, {
      method:  'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-Key':     this.apiKey,
      },
      body: JSON.stringify(body),
      signal: AbortSignal.timeout(5000),
    });
    if (!res.ok) throw new Error(`Analytico API error: ${res.status}`);
    return res.json();
  }

  async check(ip, opts = {}) {
    /** Check a single IP address. */
    return this.#post('/check.php', { ip, ...opts });
  }

  async batch(ips) {
    /** Check up to 100 IPs in one call. */
    return this.#post('/batch.php', { ips });
  }
}

// Usage (ESM / CommonJS both work)
const client = new AnalyticoClient('as_YOUR_KEY');

// Single IP
const result = await client.check('1.2.3.4');
if (result.verdict === 'blocked') {
  res.status(403).send('Access denied');
}

// Batch
const { results } = await client.batch(['1.2.3.4', '5.6.7.8']);
results.forEach(r => console.log(r.ip, r.verdict));

# Affiliate network
https://network.com/postback?click={clickid}&status={verdict}&score={fraud_score}

# DSP pixel
https://track.dsp.com/conv?cid={clickid}&sub={subid}&payout={payout}&q={quality_score}

# Internal analytics
https://analytics.yoursite.com/event?ip={ip}&event={verdict}&ts={timestamp}