WolfeGuard Synapse API Specification OAS 3.1

High-performance REST architecture and process orchestration gateway. Designed for zero-cost SQLite telemetry, multi-tenant scoped API keys, local LLM generation, dynamic slippy map tiles, and live process execution.

Production Host: https://wolfeguardsynapse.com

Direct Node: http://nodee.novanode.lol:30000

Auth Header: X-API-Key: wg_live_...

Switch to Standard Swagger →

🩺

Core & Telemetry

Health probes, gateway metadata, and status checks.

GET /

Root

WolfeGuard Synapse Gateway root endpoint. Automatically routes web browsers to the Command Dashboard; returns structured API metadata for API requests.

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /health

Health Check

Health check probe for monitoring tools and uptime checkers.

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/health" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/health"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/health', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/health');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

🔐

User Accounts & Security

Operative registration, login authentication, user profiles, credentials, and admin user controls.

POST /api/v1/auth/register

Request Payload Example

{
  "username": "operative_one",
  "password": "SecurePassword123!"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/auth/register" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"username": "operative_one", "password": "SecurePassword123!"}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/auth/register"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "username": "operative_one",
    "password": "SecurePassword123!"
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/auth/register', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "username": "operative_one",
  "password": "SecurePassword123!"
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/auth/register');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"username": "operative_one", "password": "SecurePassword123!"}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/auth/login

Request Payload Example

{
  "username": "wolfeguard",
  "password": "Lexi2024$$!!&&"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/auth/login" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"username": "wolfeguard", "password": "Lexi2024$$!!&&"}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/auth/login"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "username": "wolfeguard",
    "password": "Lexi2024$$!!&&"
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/auth/login', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "username": "wolfeguard",
  "password": "Lexi2024$$!!&&"
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/auth/login');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"username": "wolfeguard", "password": "Lexi2024$$!!&&"}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/auth/me

Get Current User Profile

Returns the profile and key details for the currently active API key.

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/auth/me" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/auth/me"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/auth/me', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/auth/me');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

PUT /api/v1/auth/me/email

Update My Email

Update email address for the currently authenticated user.

Request Payload Example

{
  "email": "[email protected]"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X PUT "https://wolfeguardsynapse.com/api/v1/auth/me/email" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"email": "[email protected]"}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/auth/me/email"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "email": "[email protected]"
}
response = requests.put(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/auth/me/email', {
  method: 'PUT',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "email": "[email protected]"
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/auth/me/email');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"email": "[email protected]"}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

PUT /api/v1/auth/me/password

Update My Password

Update password for the currently authenticated user after verifying current password.

Request Payload Example

{
  "current_password": "ExistingPassword123!",
  "new_password": "NewSecurePassword456!"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X PUT "https://wolfeguardsynapse.com/api/v1/auth/me/password" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"current_password": "ExistingPassword123!", "new_password": "NewSecurePassword456!"}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/auth/me/password"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "current_password": "ExistingPassword123!",
    "new_password": "NewSecurePassword456!"
}
response = requests.put(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/auth/me/password', {
  method: 'PUT',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "current_password": "ExistingPassword123!",
  "new_password": "NewSecurePassword456!"
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/auth/me/password');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"current_password": "ExistingPassword123!", "new_password": "NewSecurePassword456!"}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/auth/regenerate-key

Regenerate User Key

Revokes current user API key and generates a fresh one.

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/auth/regenerate-key" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/auth/regenerate-key"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.post(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/auth/regenerate-key', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/auth/regenerate-key');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/auth/users

List Users

Admin/Owner: List all registered user accounts.

Request Payload Example

{
  "username": "new_operative",
  "password": "InitPassword123!",
  "role": "user"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/auth/users" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/auth/users"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/auth/users', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/auth/users');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/auth/users

Create User By Admin

Admin/Owner: Manually create a new user, administrator, or owner account.

Request Payload Example

{
  "username": "new_operative",
  "password": "InitPassword123!",
  "role": "user"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/auth/users" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"username": "new_operative", "password": "InitPassword123!", "role": "user"}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/auth/users"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "username": "new_operative",
    "password": "InitPassword123!",
    "role": "user"
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/auth/users', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "username": "new_operative",
  "password": "InitPassword123!",
  "role": "user"
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/auth/users');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"username": "new_operative", "password": "InitPassword123!", "role": "user"}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

PUT /api/v1/auth/users/{user_id}/role

Change User Role

Admin/Owner: Update user role (owner, admin, or user).

Parameters

Name	In	Type	Required	Description
`user_id`	path	`integer`	true	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X PUT "https://wolfeguardsynapse.com/api/v1/auth/users/{user_id}/role" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/auth/users/{user_id}/role"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.put(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/auth/users/{user_id}/role', {
  method: 'PUT',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/auth/users/{user_id}/role');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/auth/users/{user_id}/reset-password

Reset User Password

Admin/Owner: Reset a user's password.

Parameters

Name	In	Type	Required	Description
`user_id`	path	`integer`	true	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/auth/users/{user_id}/reset-password" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/auth/users/{user_id}/reset-password"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.post(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/auth/users/{user_id}/reset-password', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/auth/users/{user_id}/reset-password');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

DELETE /api/v1/auth/users/{user_id}

Delete User

Admin/Owner: Permanently delete a user account from SQLite.

Parameters

Name	In	Type	Required	Description
`user_id`	path	`integer`	true	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X DELETE "https://wolfeguardsynapse.com/api/v1/auth/users/{user_id}" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/auth/users/{user_id}"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.delete(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/auth/users/{user_id}', {
  method: 'DELETE',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/auth/users/{user_id}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

🔑

API Key Hub & Scopes

Provisioning, lifecycle management, token rotation, scoped rate limits, and audit trails.

POST /api/v1/apikeys/create

Create Api Key

Provision a new custom WolfeGuard API key with scopes, rate limits, and expiration. For standard users, key ownership is automatically locked to their own account.

Request Payload Example

{
  "owner": "wolfeguard",
  "label": "Production Mobile App",
  "key_type": "live",
  "scopes": [
    "*"
  ],
  "rate_limit_per_hour": 1000
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/apikeys/create" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"owner": "wolfeguard", "label": "Production Mobile App", "key_type": "live", "scopes": ["*"], "rate_limit_per_hour": 1000}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/apikeys/create"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "owner": "wolfeguard",
    "label": "Production Mobile App",
    "key_type": "live",
    "scopes": [
        "*"
    ],
    "rate_limit_per_hour": 1000
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/apikeys/create', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "owner": "wolfeguard",
  "label": "Production Mobile App",
  "key_type": "live",
  "scopes": [
    "*"
  ],
  "rate_limit_per_hour": 1000
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/apikeys/create');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"owner": "wolfeguard", "label": "Production Mobile App", "key_type": "live", "scopes": ["*"], "rate_limit_per_hour": 1000}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/apikeys/list

List Api Keys

List provisioned API keys (never exposes raw keys). Regular users can ONLY EVER see keys that THEY created. Administrators and Owners can toggle between their own keys and all platform keys.

Parameters

Name	In	Type	Required	Description
`owner`	query	`string`	opt	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/apikeys/list" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/apikeys/list"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/apikeys/list', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/apikeys/list');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/apikeys/revoke/{key_id}

Revoke Api Key

Instantly revoke an API key. Users can only revoke their own keys.

Parameters

Name	In	Type	Required	Description
`key_id`	path	`integer`	true	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/apikeys/revoke/{key_id}" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/apikeys/revoke/{key_id}"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.post(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/apikeys/revoke/{key_id}', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/apikeys/revoke/{key_id}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

DELETE /api/v1/apikeys/{key_id}

Delete Api Key

Permanently purge and delete an API key. Users can only delete their own keys.

Parameters

Name	In	Type	Required	Description
`key_id`	path	`integer`	true	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X DELETE "https://wolfeguardsynapse.com/api/v1/apikeys/{key_id}" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/apikeys/{key_id}"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.delete(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/apikeys/{key_id}', {
  method: 'DELETE',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/apikeys/{key_id}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

DELETE /api/v1/apikeys/delete/{key_id}

Delete Api Key

Permanently purge and delete an API key. Users can only delete their own keys.

Parameters

Name	In	Type	Required	Description
`key_id`	path	`integer`	true	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X DELETE "https://wolfeguardsynapse.com/api/v1/apikeys/delete/{key_id}" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/apikeys/delete/{key_id}"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.delete(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/apikeys/delete/{key_id}', {
  method: 'DELETE',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/apikeys/delete/{key_id}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/apikeys/rotate/{key_id}

Rotate Api Key

Generate a new key that inherits all settings from the old key. Users can only rotate their own keys.

Parameters

Name	In	Type	Required	Description
`key_id`	path	`integer`	true	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/apikeys/rotate/{key_id}" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/apikeys/rotate/{key_id}"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.post(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/apikeys/rotate/{key_id}', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/apikeys/rotate/{key_id}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

PUT /api/v1/apikeys/update/{key_id}

Update Api Key

Update an existing key's label, scopes, or rate limit.

Parameters

Name	In	Type	Required	Description
`key_id`	path	`integer`	true	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X PUT "https://wolfeguardsynapse.com/api/v1/apikeys/update/{key_id}" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/apikeys/update/{key_id}"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.put(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/apikeys/update/{key_id}', {
  method: 'PUT',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/apikeys/update/{key_id}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/apikeys/stats

Get Api Key Stats

Aggregate statistics: total keys, active/revoked, request counts, owners. Scoped to the authenticated user for regular operatives.

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/apikeys/stats" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/apikeys/stats"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/apikeys/stats', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/apikeys/stats');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/apikeys/audit

Get Audit Log

Returns API key lifecycle events, scoped to the caller for regular users.

Parameters

Name	In	Type	Required	Description
`limit`	query	`integer`	opt	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/apikeys/audit" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/apikeys/audit"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/apikeys/audit', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/apikeys/audit');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/apikeys/validate

Validate Api Key Endpoint

Validate any WolfeGuard API key — checks existence, expiration, and active status.

Parameters

Name	In	Type	Required	Description
`raw_key`	query	`string`	true	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/apikeys/validate" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/apikeys/validate"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.post(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/apikeys/validate', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/apikeys/validate');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/apikeys/rate-limit/{raw_key}

Check Key Rate Limit

Check rate limit status for a given API key.

Parameters

Name	In	Type	Required	Description
`raw_key`	path	`string`	true	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/apikeys/rate-limit/{raw_key}" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/apikeys/rate-limit/{raw_key}"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/apikeys/rate-limit/{raw_key}', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/apikeys/rate-limit/{raw_key}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

🧠

Neural AI Engine

Text generation, multi-turn prompt completions, and asynchronous model training pipelines.

POST /api/v1/ai/generate

Generate Text

Run immediate text generation or chat completion through local Ollama or OpenAI.

Request Payload Example

{
  "prompt": "Analyze the telemetry stream and summarize anomalies.",
  "max_tokens": 256,
  "temperature": 0.7
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/ai/generate" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"prompt": "Analyze the telemetry stream and summarize anomalies.", "max_tokens": 256, "temperature": 0.7}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/ai/generate"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "prompt": "Analyze the telemetry stream and summarize anomalies.",
    "max_tokens": 256,
    "temperature": 0.7
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/ai/generate', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "prompt": "Analyze the telemetry stream and summarize anomalies.",
  "max_tokens": 256,
  "temperature": 0.7
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/ai/generate');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"prompt": "Analyze the telemetry stream and summarize anomalies.", "max_tokens": 256, "temperature": 0.7}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/ai/train

Trigger Training Job

Queue an asynchronous AI training / fine-tuning job in the background task manager. Returns a Task ID immediately to track progress and epoch logs.

Request Payload Example

{
  "model_name": "synapse-recon-v1",
  "epochs": 5,
  "dataset_url": "https://example.com/dataset.json"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/ai/train" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"model_name": "synapse-recon-v1", "epochs": 5, "dataset_url": "https://example.com/dataset.json"}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/ai/train"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "model_name": "synapse-recon-v1",
    "epochs": 5,
    "dataset_url": "https://example.com/dataset.json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/ai/train', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "model_name": "synapse-recon-v1",
  "epochs": 5,
  "dataset_url": "https://example.com/dataset.json"
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/ai/train');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"model_name": "synapse-recon-v1", "epochs": 5, "dataset_url": "https://example.com/dataset.json"}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

🗺️

Maps & Geospatial Engine

Slippy map tile rendering, forward/reverse geocoding, static map snapshots, distance math, POIs, and custom layer overlays.

GET /api/v1/maps/tiles/{z}/{x}/{y}.png

Serve High-Speed Slippy Map Tile

Slippy Map XYZ tile service formatted for Leaflet, MapLibre GL, and OpenLayers. All tiles are processed in real-time with custom color matrices and cached locally. Supports ?key=YOUR_API_KEY for developer authentication and usage analytics.

Parameters

Name	In	Type	Required	Description
`z`	path	`integer`	true	-
`x`	path	`integer`	true	-
`y`	path	`integer`	true	-
`theme`	query	`string`	opt	Map visual style: cyber_noir, crimson_tactical, dark_matter, satellite, osm_light
`key`	query	`string`	opt	WolfeGuard Map API Key (e.g. wg_live_...) for tracking/billing
`apiKey`	query	`string`	opt	Alias for key parameter

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/maps/tiles/{z}/{x}/{y}.png" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/maps/tiles/{z}/{x}/{y}.png"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/maps/tiles/{z}/{x}/{y}.png', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/maps/tiles/{z}/{x}/{y}.png');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/maps/geocode

Forward Geocoding & Address Search

Resolves human-readable addresses, cities, and landmarks into precise GPS coordinates. Prioritizes local WolfeGuard POIs before fallback to cached OpenStreetMap data.

Parameters

Name	In	Type	Required	Description
`q`	query	`string`	true	Address, landmark, city, or coordinates
`limit`	query	`integer`	opt	Maximum number of search results

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/maps/geocode" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/maps/geocode"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/maps/geocode', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/maps/geocode');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/maps/reverse

Reverse Geocoding

Resolves geographic latitude and longitude coordinates back into an address and territory.

Parameters

Name	In	Type	Required	Description
`lat`	query	`number`	true	Target latitude
`lon`	query	`number`	true	Target longitude

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/maps/reverse" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/maps/reverse"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/maps/reverse', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/maps/reverse');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/maps/static

Generate High-Resolution Static Map Snapshot

Renders and exports a static map image with tactical crosshairs and glowing scarlet markers on-the-fly.

Parameters

Name	In	Type	Required	Description
`lat`	query	`number`	true	Center latitude
`lon`	query	`number`	true	Center longitude
`zoom`	query	`integer`	opt	Zoom level (1-19)
`width`	query	`integer`	opt	Image width in pixels
`height`	query	`integer`	opt	Image height in pixels
`theme`	query	`string`	opt	Theme: cyber_noir, crimson_tactical, dark_matter, satellite
`markers`	query	`string`	opt	JSON array of markers or single label (e.g. '[{"lat":40.7,"lon":-74,"label":"Target"}]')

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/maps/static" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/maps/static"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/maps/static', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/maps/static');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/maps/distance

Great-Circle Distance & Bearing Engine

Computes precise Haversine distance, initial bearing azimuth, compass heading, midpoint coordinates, and estimated travel times.

Request Payload Example

{
  "from_lat": 40.7128,
  "from_lon": -74.006,
  "to_lat": 34.0522,
  "to_lon": -118.2437
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/maps/distance" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"from_lat": 40.7128, "from_lon": -74.006, "to_lat": 34.0522, "to_lon": -118.2437}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/maps/distance"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "from_lat": 40.7128,
    "from_lon": -74.006,
    "to_lat": 34.0522,
    "to_lon": -118.2437
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/maps/distance', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "from_lat": 40.7128,
  "from_lon": -74.006,
  "to_lat": 34.0522,
  "to_lon": -118.2437
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/maps/distance');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"from_lat": 40.7128, "from_lon": -74.006, "to_lat": 34.0522, "to_lon": -118.2437}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/maps/pois

List Saved Tactical POIs & Markers

Fetches user-saved tactical points of interest, safehouses, and landmarks from SQLite.

Parameters

Name	In	Type	Required	Description
`category`	query	`string`	opt	Optional category filter
`limit`	query	`integer`	opt	Result limit

Request Payload Example

{
  "name": "Forward HQ",
  "lat": 40.7128,
  "lon": -74.006,
  "category": "command"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/maps/pois" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/maps/pois"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/maps/pois', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/maps/pois');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/maps/pois

Save New Tactical POI

Saves a new custom point of interest to the database for instant geocoding and rendering.

Request Payload Example

{
  "name": "Forward HQ",
  "lat": 40.7128,
  "lon": -74.006,
  "category": "command"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/maps/pois" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"name": "Forward HQ", "lat": 40.7128, "lon": -74.006, "category": "command"}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/maps/pois"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "name": "Forward HQ",
    "lat": 40.7128,
    "lon": -74.006,
    "category": "command"
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/maps/pois', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "name": "Forward HQ",
  "lat": 40.7128,
  "lon": -74.006,
  "category": "command"
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/maps/pois');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"name": "Forward HQ", "lat": 40.7128, "lon": -74.006, "category": "command"}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

DELETE /api/v1/maps/pois/{poi_id}

Delete Tactical POI

Removes a custom POI from the database.

Parameters

Name	In	Type	Required	Description
`poi_id`	path	`integer`	true	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X DELETE "https://wolfeguardsynapse.com/api/v1/maps/pois/{poi_id}" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/maps/pois/{poi_id}"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.delete(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/maps/pois/{poi_id}', {
  method: 'DELETE',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/maps/pois/{poi_id}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/maps/styles

Get Map Styles & Tile Provider Metadata

Provides tile URL templates and visual style metadata compatible with MapLibre GL and Leaflet.

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/maps/styles" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/maps/styles"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/maps/styles', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/maps/styles');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/maps/layers

List Custom User Map Layers & Polygons

Retrieves all custom user-drawn polygons, tactical boundaries, and flight corridors.

Request Payload Example

{
  "key": "radar_grid",
  "name": "Tactical Radar Grid",
  "data": {
    "type": "FeatureCollection",
    "features": []
  }
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/maps/layers" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/maps/layers"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/maps/layers', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/maps/layers');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/maps/layers

Save Custom User Map Layer or Territory

Saves a user-crafted polygon, territory boundary, or route into SQLite.

Request Payload Example

{
  "key": "radar_grid",
  "name": "Tactical Radar Grid",
  "data": {
    "type": "FeatureCollection",
    "features": []
  }
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/maps/layers" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"key": "radar_grid", "name": "Tactical Radar Grid", "data": {"type": "FeatureCollection", "features": []}}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/maps/layers"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "key": "radar_grid",
    "name": "Tactical Radar Grid",
    "data": {
        "type": "FeatureCollection",
        "features": []
    }
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/maps/layers', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "key": "radar_grid",
  "name": "Tactical Radar Grid",
  "data": {
    "type": "FeatureCollection",
    "features": []
  }
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/maps/layers');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"key": "radar_grid", "name": "Tactical Radar Grid", "data": {"type": "FeatureCollection", "features": []}}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

DELETE /api/v1/maps/layers/{key}

Delete Custom Map Layer

Deletes a user-crafted polygon or territory layer.

Parameters

Name	In	Type	Required	Description
`key`	path	`string`	true	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X DELETE "https://wolfeguardsynapse.com/api/v1/maps/layers/{key}" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/maps/layers/{key}"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.delete(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/maps/layers/{key}', {
  method: 'DELETE',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/maps/layers/{key}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/maps/export

Export Complete Custom Map as GeoJSON

Bundles all custom POIs, markers, and user-drawn territories into a single GeoJSON FeatureCollection.

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/maps/export" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/maps/export"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/maps/export', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/maps/export');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

💾

Database & JSON Storage

Zero-cost local SQLite document storage, collections, and raw parameterized query execution.

GET /api/v1/storage/meta

Get Database Meta

Get SQLite database file stats, disk path, and table row counts.

Request Payload Example

{
  "item_id": "doc_001",
  "name": "Telemetry Node Alpha",
  "status": "active"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/storage/meta" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/storage/meta"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/storage/meta', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/storage/meta');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/storage/query

Run Sql Query

Run custom SQL queries against the local SQLite database.

Request Payload Example

{
  "sql": "SELECT name, role FROM users LIMIT 10",
  "params": []
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/storage/query" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"sql": "SELECT name, role FROM users LIMIT 10", "params": []}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/storage/query"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "sql": "SELECT name, role FROM users LIMIT 10",
    "params": []
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/storage/query', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "sql": "SELECT name, role FROM users LIMIT 10",
  "params": []
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/storage/query');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"sql": "SELECT name, role FROM users LIMIT 10", "params": []}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/storage/{collection}

Store Collection Record

Store or update any arbitrary JSON data into a named collection for free.

Parameters

Name	In	Type	Required	Description
`collection`	path	`string`	true	-

Request Payload Example

{
  "item_id": "doc_001",
  "name": "Telemetry Node Alpha",
  "status": "active"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/storage/{collection}" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"item_id": "doc_001", "name": "Telemetry Node Alpha", "status": "active"}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/storage/{collection}"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "item_id": "doc_001",
    "name": "Telemetry Node Alpha",
    "status": "active"
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/storage/{collection}', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "item_id": "doc_001",
  "name": "Telemetry Node Alpha",
  "status": "active"
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/storage/{collection}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"item_id": "doc_001", "name": "Telemetry Node Alpha", "status": "active"}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/storage/{collection}

List Collection Records

Retrieve all documents inside a given collection.

Parameters

Name	In	Type	Required	Description
`collection`	path	`string`	true	-
`limit`	query	`integer`	opt	-

Request Payload Example

{
  "item_id": "doc_001",
  "name": "Telemetry Node Alpha",
  "status": "active"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/storage/{collection}" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/storage/{collection}"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/storage/{collection}', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/storage/{collection}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/storage/{collection}/{key}

Get Collection Record

Get a specific document by its key from a collection.

Parameters

Name	In	Type	Required	Description
`collection`	path	`string`	true	-
`key`	path	`string`	true	-

Request Payload Example

{
  "item_id": "doc_001",
  "name": "Telemetry Node Alpha",
  "status": "active"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/storage/{collection}/{key}" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/storage/{collection}/{key}"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/storage/{collection}/{key}', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/storage/{collection}/{key}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

DELETE /api/v1/storage/{collection}/{key}

Delete Collection Record

Delete a document from a collection.

Parameters

Name	In	Type	Required	Description
`collection`	path	`string`	true	-
`key`	path	`string`	true	-

Request Payload Example

{
  "item_id": "doc_001",
  "name": "Telemetry Node Alpha",
  "status": "active"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X DELETE "https://wolfeguardsynapse.com/api/v1/storage/{collection}/{key}" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/storage/{collection}/{key}"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.delete(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/storage/{collection}/{key}', {
  method: 'DELETE',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/storage/{collection}/{key}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

🛠️

Universal Web & Utilities

Multi-algorithm cryptographic hashes, UUID generation, OpenGraph metadata scrapers, HTML-to-Markdown converters, and SVG QR codes.

POST /api/v1/utils/hashes

Compute Cryptographic Hashes & HMAC

Processes requests for this route.

Request Payload Example

{
  "text": "WolfeGuard Synapse Security Mesh 2026",
  "algorithms": [
    "sha256",
    "sha512",
    "md5"
  ]
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/utils/hashes" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"text": "WolfeGuard Synapse Security Mesh 2026", "algorithms": ["sha256", "sha512", "md5"]}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/utils/hashes"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "text": "WolfeGuard Synapse Security Mesh 2026",
    "algorithms": [
        "sha256",
        "sha512",
        "md5"
    ]
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/utils/hashes', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "text": "WolfeGuard Synapse Security Mesh 2026",
  "algorithms": [
    "sha256",
    "sha512",
    "md5"
  ]
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/utils/hashes');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"text": "WolfeGuard Synapse Security Mesh 2026", "algorithms": ["sha256", "sha512", "md5"]}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/utils/qr

Generate Pure Vector QR Code SVG

Processes requests for this route.

Parameters

Name	In	Type	Required	Description
`text`	query	`string`	opt	Data payload to encode
`size`	query	`integer`	opt	QR code dimension in pixels
`foreground`	query	`string`	opt	Foreground hex color
`background`	query	`string`	opt	Background hex color

Request Payload Example

{
  "text": "https://wolfeguardsynapse.com/dashboard",
  "size": 300
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/utils/qr" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/utils/qr"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/utils/qr', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/utils/qr');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/utils/qr

Generate Vector QR Code SVG

Processes requests for this route.

Request Payload Example

{
  "text": "https://wolfeguardsynapse.com/dashboard",
  "size": 300
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/utils/qr" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"text": "https://wolfeguardsynapse.com/dashboard", "size": 300}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/utils/qr"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "text": "https://wolfeguardsynapse.com/dashboard",
    "size": 300
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/utils/qr', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "text": "https://wolfeguardsynapse.com/dashboard",
  "size": 300
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/utils/qr');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"text": "https://wolfeguardsynapse.com/dashboard", "size": 300}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/utils/uuid

Bulk Secure UUID & Token Generator

Processes requests for this route.

Parameters

Name	In	Type	Required	Description
`count`	query	`integer`	opt	Number of tokens to generate
`format_type`	query	`string`	opt	Format: v4, v4_hex, nanoid, alphanumeric

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/utils/uuid" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/utils/uuid"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/utils/uuid', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/utils/uuid');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/utils/opengraph

Extract OpenGraph & URL Metadata

Processes requests for this route.

Request Payload Example

{
  "url": "https://github.com"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/utils/opengraph" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"url": "https://github.com"}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/utils/opengraph"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "url": "https://github.com"
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/utils/opengraph', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "url": "https://github.com"
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/utils/opengraph');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"url": "https://github.com"}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/utils/html2md

Convert HTML to Markdown

Processes requests for this route.

Request Payload Example

{
  "html": "<h1>Synapse Recon</h1><p>Active nodes verified.</p>"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/utils/html2md" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"html": "<h1>Synapse Recon</h1><p>Active nodes verified.</p>"}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/utils/html2md"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "html": "<h1>Synapse Recon</h1><p>Active nodes verified.</p>"
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/utils/html2md', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "html": "<h1>Synapse Recon</h1><p>Active nodes verified.</p>"
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/utils/html2md');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"html": "<h1>Synapse Recon</h1><p>Active nodes verified.</p>"}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/utils/webhook

Dispatch Signed Webhook

Processes requests for this route.

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/utils/webhook" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/utils/webhook"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.post(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/utils/webhook', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/utils/webhook');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

⚡

System & Exec Runner

Server-side executable runner, process management, process spawning, and real-time hardware telemetry.

GET /api/v1/system/metrics

Get Metrics

Get live host hardware metrics (CPU, RAM, Disk, OS environment).

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/system/metrics" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/system/metrics"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/system/metrics', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/system/metrics');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/system/execute

Execute Command

Execute a command or external tool synchronously and return stdout, stderr, and exit code.

Request Payload Example

{
  "command": "uptime"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/system/execute" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"command": "uptime"}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/system/execute"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "command": "uptime"
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/system/execute', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "command": "uptime"
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/system/execute');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"command": "uptime"}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

POST /api/v1/system/spawn

Spawn Background Process

Launch an executable, bot, or script in the background. Streams output into task logs.

Request Payload Example

{
  "command": "ls -la /"
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X POST "https://wolfeguardsynapse.com/api/v1/system/spawn" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" -d '{"command": "ls -la /"}'

import requests

url = "https://wolfeguardsynapse.com/api/v1/system/spawn"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "command": "ls -la /"
}
response = requests.post(url, json=payload, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/system/spawn', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
  "command": "ls -la /"
})
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/system/spawn');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => '{"command": "ls -la /"}'
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

📋

Task Queue & Workers

Asynchronous background task submission, status tracking, execution outputs, and task cancellation.

GET /api/v1/tasks

List Recent Tasks

List recently submitted background tasks, their status, and timestamps.

Parameters

Name	In	Type	Required	Description
`limit`	query	`integer`	opt	-

Request Payload Example

{
  "task_type": "data_indexing",
  "payload": {
    "collection": "logs",
    "limit": 100
  }
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/tasks" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/tasks"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/tasks', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/tasks');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));

GET /api/v1/tasks/{task_id}

Get Task Details

Get real-time status, logs, and output of a specific background task.

Parameters

Name	In	Type	Required	Description
`task_id`	path	`string`	true	-

Request Payload Example

{
  // Optional JSON body
}

Expected Response Schema

{
  "success": true,
  "status": "ok",
  "data": { ... },
  "error": null,
  "meta": {
    "timestamp": "2026-10-29T02:45:00Z",
    "requestId": "uuid"
  }
}

curl -X GET "https://wolfeguardsynapse.com/api/v1/tasks/{task_id}" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

import requests

url = "https://wolfeguardsynapse.com/api/v1/tasks/{task_id}"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const response = await fetch('https://wolfeguardsynapse.com/api/v1/tasks/{task_id}', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});
const data = await response.json();
console.log(data);

<?php
$ch = curl_init('https://wolfeguardsynapse.com/api/v1/tasks/{task_id}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Content-Type: application/json'
    ]
]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));