API calls

ACCOUNT_ID=YOUR_ACCOUNT_ID
API_KEY=gv_YOUR_KEY

curl https://$ACCOUNT_ID.api.getvisitor.info/ \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "ip": "84.198.10.20",
    "ua": "Mozilla/5.0 (Linux; Android 14; SM-S928B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Mobile Safari/537.36"
  }'

# gem install net-http-persistent
require "net/http/persistent"
require "json"

ACCOUNT_ID = "YOUR_ACCOUNT_ID"
API_KEY = "gv_YOUR_KEY"

# Reuse this client across requests. Don't create a new one per call.
HTTP = Net::HTTP::Persistent.new(name: "getvisitor")

def lookup(ip:, ua:)
  uri = URI("https://#{ACCOUNT_ID}.api.getvisitor.info/")
  req = Net::HTTP::Post.new(uri)
  req["Authorization"] = "Bearer #{API_KEY}"
  req["Content-Type"] = "application/json"
  req.body = { ip: ip, ua: ua }.to_json

  JSON.parse(HTTP.request(uri, req).body)
end

# lookup(ip: "84.198.10.20", ua: request.user_agent)

import requests

ACCOUNT_ID = "YOUR_ACCOUNT_ID"
API_KEY = "gv_YOUR_KEY"

# Reuse this session across requests. Don't create a new one per call.
session = requests.Session()
session.headers["Authorization"] = f"Bearer {API_KEY}"

def lookup(ip, ua):
    response = session.post(f"https://{ACCOUNT_ID}.api.getvisitor.info/", json={"ip": ip, "ua": ua})
    return response.json()

# lookup("84.198.10.20", request.headers["User-Agent"])

// A traditional PHP-FPM request is its own short-lived process, so
// there's no long-running client object to reuse ACROSS requests the
// way the other examples here do. curl's own keep-alive still reuses
// the TCP/TLS connection for MULTIPLE calls made within the SAME
// request when you keep using the same curl handle, which is what this
// does. If you're on a long-running PHP runtime (Swoole, RoadRunner),
// hold $ch in a worker-scoped variable instead of opening it per request.

$accountId = "YOUR_ACCOUNT_ID";
$apiKey = "gv_YOUR_KEY";

function lookup($ch, $accountId, $apiKey, $ip, $ua) {
    curl_setopt_array($ch, [
        CURLOPT_URL => "https://{$accountId}.api.getvisitor.info/",
        CURLOPT_POST => true,
        CURLOPT_HTTPHEADER => [
            "Authorization: Bearer {$apiKey}",
            "Content-Type: application/json",
        ],
        CURLOPT_POSTFIELDS => json_encode(["ip" => $ip, "ua" => $ua]),
        CURLOPT_RETURNTRANSFER => true,
    ]);
    return json_decode(curl_exec($ch), true);
}

$ch = curl_init();
// lookup($ch, $accountId, $apiKey, "84.198.10.20", $_SERVER["HTTP_USER_AGENT"]);
curl_close($ch);

const ACCOUNT_ID = "YOUR_ACCOUNT_ID";
const API_KEY = "gv_YOUR_KEY";

// fetch() reuses the underlying connection across calls to the same
// origin automatically. No explicit client/session object needed here.
async function lookup(ip, ua) {
  const response = await fetch(`https://${ACCOUNT_ID}.api.getvisitor.info/`, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ ip, ua }),
  });
  return response.json();
}

// lookup("84.198.10.20", req.headers["user-agent"]);

package main

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

const accountID = "YOUR_ACCOUNT_ID"
const apiKey = "gv_YOUR_KEY"

// http.DefaultClient reuses connections across calls automatically.
// Its Transport pools them by default, as long as you keep using the
// SAME client, not a fresh http.Client{} constructed per call.
func lookup(ip, ua string) (map[string]interface{}, error) {
	payload, err := json.Marshal(map[string]string{"ip": ip, "ua": ua})
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", "https://"+accountID+".api.getvisitor.info/", bytes.NewBuffer(payload))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var result map[string]interface{}
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return nil, err
	}
	return result, nil
}

// lookup("84.198.10.20", r.Header.Get("User-Agent"))

static final String ACCOUNT_ID = "YOUR_ACCOUNT_ID";
static final String API_KEY = "gv_YOUR_KEY";

// HttpClient reuses connections across calls automatically, as long as
// you keep using the SAME client. Never HttpClient.newHttpClient() per call.
static final HttpClient client = HttpClient.newHttpClient();

static String lookup(String ip, String ua) throws Exception {
    String body = String.format(
        """
        {"ip": "%s", "ua": "%s"}""",
        ip.replace("\"", "\\\""), ua.replace("\"", "\\\"")
    );

    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://" + ACCOUNT_ID + ".api.getvisitor.info/"))
        .header("Authorization", "Bearer " + API_KEY)
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(body))
        .build();

    HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
    return response.body();
}

// lookup("84.198.10.20", request.getHeader("User-Agent"));

const string AccountId = "YOUR_ACCOUNT_ID";
const string ApiKey = "gv_YOUR_KEY";

// Reuse ONE client for the life of your process. Never `using var client
// = new HttpClient()` per call, which disposes the underlying connection
// immediately and is a well-known source of socket exhaustion under load.
static readonly HttpClient client = new();

static async Task<JsonElement> Lookup(string ip, string ua)
{
    if (!client.DefaultRequestHeaders.Contains("Authorization"))
        client.DefaultRequestHeaders.Add("Authorization", "Bearer " + ApiKey);

    var payload = new { ip, ua };
    var response = await client.PostAsJsonAsync($"https://{AccountId}.api.getvisitor.info/", payload);
    return await response.Content.ReadFromJsonAsync<JsonElement>();
}

// await Lookup("84.198.10.20", Request.Headers.UserAgent.ToString());

require "http/client"
require "json"

ACCOUNT_ID = "YOUR_ACCOUNT_ID"
API_KEY    = "gv_YOUR_KEY"

# Reuse this client across requests. Don't create a new one per call.
CLIENT = HTTP::Client.new("#{ACCOUNT_ID}.api.getvisitor.info", tls: true)

def lookup(ip : String, ua : String)
  headers = HTTP::Headers{"Authorization" => "Bearer #{API_KEY}", "Content-Type" => "application/json"}
  body = {ip: ip, ua: ua}.to_json
  response = CLIENT.post("/", headers: headers, body: body)
  JSON.parse(response.body)
end

# lookup("84.198.10.20", request.headers["User-Agent"])