Competitor Research Tool API Documentation

pip install requests
---
import requests

API_KEY = "YOUR_API_KEY"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}
BASE    = "https://api.pixelapi.dev/v1/geomind"
KEYWORD = "seo competitor analysis"

# Step 1 — competitor SERP positions
disp = requests.get(f"{BASE}/competitor/displacement",
                    params={"keyword": KEYWORD}, headers=HEADERS).json()
for c in disp["competitors"]:
    print(f"{c['domain']:30s}  pos={c['position']}  delta={c['change']:+d}  traffic≈{c['estimated_traffic']:,}")

# Step 2 — keyword sentiment
sent = requests.get(f"{BASE}/sentiment",
                    params={"keyword": KEYWORD}, headers=HEADERS).json()
print(f"Sentiment: {sent['overall']} (score {sent['score']:.2f})")

# Step 3 — citation velocity
vel = requests.get(f"{BASE}/citation/velocity",
                   params={"keyword": KEYWORD}, headers=HEADERS).json()
print(f"Citation velocity 7d: {vel['velocity_7d']}, acceleration: {vel['acceleration']:.2f}")

# Step 4 — active alerts
alerts = requests.get(f"{BASE}/alerts", headers=HEADERS).json()
for a in alerts["alerts"]:
    print(f"[{a['severity'].upper()}] {a['type']} — {a['message']}")

# Step 5 — save audit snapshot
saved = requests.post(f"{BASE}/scan/save", headers=HEADERS,
    json={"url": "example.com", "keyword": KEYWORD, "score": 82, "grade": "A"}).json()
print(f"Saved scan_id: {saved['scan_id']}")

npm install node-fetch
---
import fetch from "node-fetch";

const API_KEY = process.env.PIXELAPI_KEY;
const BASE    = "https://api.pixelapi.dev/v1/geomind";
const KEYWORD = "seo competitor analysis";
const auth    = { Authorization: `Bearer ${API_KEY}` };

// Competitor SERP positions
const disp = await fetch(
  `${BASE}/competitor/displacement?keyword=${encodeURIComponent(KEYWORD)}`,
  { headers: auth }
).then(r => r.json());

console.table(disp.competitors.map(c => ({
  domain:   c.domain,
  position: c.position,
  delta:    c.change,
  traffic:  c.estimated_traffic,
})));

// Sentiment
const sent = await fetch(
  `${BASE}/sentiment?keyword=${encodeURIComponent(KEYWORD)}`, { headers: auth }
).then(r => r.json());
console.log(`Sentiment: ${sent.overall} (${sent.score.toFixed(2)})`);

// Active alerts
const alerts = await fetch(`${BASE}/alerts`, { headers: auth }).then(r => r.json());
console.log(`${alerts.active_alerts} active alerts`);

// No SDK needed — plain PHP curl
<?php
$apiKey = getenv("PIXELAPI_KEY");
$base   = "https://api.pixelapi.dev/v1/geomind";
$kw     = urlencode("seo competitor analysis");

function geomind_get(string $url, string $apiKey): array {
    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER     => ["Authorization: Bearer $apiKey"],
    ]);
    $body = curl_exec($ch);
    curl_close($ch);
    return json_decode($body, true);
}

// Competitor positions
$disp = geomind_get("$base/competitor/displacement?keyword=$kw", $apiKey);
foreach ($disp["competitors"] as $c) {
    printf("%-30s pos=%d  delta=%+d  traffic=%s\n",
        $c["domain"], $c["position"], $c["change"],
        number_format($c["estimated_traffic"]));
}

// Alerts
$alerts = geomind_get("$base/alerts", $apiKey);
foreach ($alerts["alerts"] as $a) {
    echo "[{$a['severity']}] {$a['type']} — {$a['message']}\n";
}

// Save audit
$ch = curl_init("$base/scan/save");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => ["Authorization: Bearer $apiKey", "Content-Type: application/json"],
    CURLOPT_POSTFIELDS     => json_encode(["url"=>"example.com","keyword"=>"seo competitor analysis","score"=>82,"grade"=>"A"]),
]);
$saved = json_decode(curl_exec($ch), true);
echo "Saved scan_id: {$saved['scan_id']}\n";

require "uri"
require "net/http"
require "json"

API_KEY = ENV["PIXELAPI_KEY"]
BASE    = "https://api.pixelapi.dev/v1/geomind"
KEYWORD = "seo competitor analysis"

def geomind_get(path, api_key, params = {})
  uri = URI("#{BASE}#{path}")
  uri.query = URI.encode_www_form(params) unless params.empty?
  req = Net::HTTP::Get.new(uri)
  req["Authorization"] = "Bearer #{api_key}"
  resp = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
  JSON.parse(resp.body)
end

# Competitor positions
disp = geomind_get("/competitor/displacement", API_KEY, keyword: KEYWORD)
disp["competitors"].each do |c|
  printf("%-30s pos=%d  delta=%+d  traffic=%d\n",
    c["domain"], c["position"], c["change"], c["estimated_traffic"])
end

# Alerts
alerts = geomind_get("/alerts", API_KEY)
puts "#{alerts['active_alerts']} active alerts"

# Save audit
uri = URI("#{BASE}/scan/save")
req = Net::HTTP::Post.new(uri, "Authorization" => "Bearer #{API_KEY}", "Content-Type" => "application/json")
req.body = JSON.generate(url: "example.com", keyword: KEYWORD, score: 82, grade: "A")
resp = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts "Saved scan_id: #{JSON.parse(resp.body)['scan_id']}"

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "strings"
)

func geomindGet(path, apiKey, keyword string) map[string]interface{} {
    base := "https://api.pixelapi.dev/v1/geomind"
    u := base + path
    if keyword != "" {
        u += "?keyword=" + url.QueryEscape(keyword)
    }
    req, _ := http.NewRequest("GET", u, nil)
    req.Header.Set("Authorization", "Bearer "+apiKey)
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var result map[string]interface{}
    json.Unmarshal(body, &result)
    return result
}

func main() {
    apiKey  := os.Getenv("PIXELAPI_KEY")
    keyword := "seo competitor analysis"

    // Competitor positions
    disp := geomindGet("/competitor/displacement", apiKey, keyword)
    for _, c := range disp["competitors"].([]interface{}) {
        comp := c.(map[string]interface{})
        fmt.Printf("%-30s pos=%.0f  delta=%.0f  traffic=%.0f\n",
            comp["domain"], comp["position"], comp["change"], comp["estimated_traffic"])
    }

    // Alerts
    alerts := geomindGet("/alerts", apiKey, "")
    fmt.Printf("Active alerts: %.0f\n", alerts["active_alerts"])

    // Save audit
    payload := `{"url":"example.com","keyword":"seo competitor analysis","score":82,"grade":"A"}`
    req, _ := http.NewRequest("POST",
        "https://api.pixelapi.dev/v1/geomind/scan/save",
        strings.NewReader(payload))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var saved map[string]interface{}
    json.Unmarshal(body, &saved)
    fmt.Printf("Saved scan_id: %.0f\n", saved["scan_id"])
}