Public API Reference

{
  "success": true,
  "data": [...],
  "pagination": {
    "total": 1234,
    "page": 1,
    "limit": 100,
    "totalPages": 13,
    "hasNext": true,
    "hasPrev": false
  },
  "meta": {
    "table": "site",
    "columns": ["site_id", "name", "latitude", "longitude"],
    "filters": {},
    "queryTimeMs": 45
  },
  "rateLimit": {
    "limit": 1000,
    "remaining": 999,
    "resetAt": "2025-01-01T00:01:00.000Z"
  }
}

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.example.com/api/v1/schema"

{
  "success": true,
  "tables": [
    { "name": "site", "description": "Transmitter site locations", "estimatedRows": "~127,000" },
    { "name": "licence", "description": "Radio communication licences", "estimatedRows": "~163,000" },
    ...
  ]
}

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.example.com/api/v1/schema?table=site"

{
  "success": true,
  "schema": {
    "table": "site",
    "description": "Transmitter site locations",
    "estimatedRows": "~127,000",
    "primaryKey": "site_id",
    "columns": [
      { "name": "site_id", "type": "string", "nullable": false, "filterable": true, "sortable": true, "description": "Unique site identifier" },
      { "name": "latitude", "type": "number", "nullable": true, "filterable": true, "sortable": true, "description": "Latitude in decimal degrees (WGS84)" },
      ...
    ]
  }
}

{
  "siteId": "string (required)",
  "reference": {
    "licenceNo": "string"
  }
}

{
  "siteId": "string (required)",
  "reference": {
    "frequency": 450000000,
    "bandwidth": 25000
  }
}

{
  "success": true,
  "data": {
    "reference": {
      "frequency": 450000000,
      "bandwidth": 25000,
      "licenceNo": "1234567/1",
      "source": "licence"
    },
    "siteId": "10001",
    "siteName": "MOUNT DANDENONG",
    "deviceCount": 45,
    "products": [
      {
        "productType": "2f1-f2",
        "frequency": 449750000,
        "bandwidth": 75000,
        "device1": {
          "sddId": "123456",
          "licenceNo": "1234567/1",
          "frequency": 450000000
        },
        "device2": {
          "sddId": "123457",
          "licenceNo": "1234568/1",
          "frequency": 450250000
        },
        "overlapStatus": "partial",
        "overlapPercentage": 35,
        "separationHz": 0
      }
    ],
    "summary": {
      "totalProducts": 124,
      "fullOverlaps": 2,
      "partialOverlaps": 5,
      "adjacentProducts": 12,
      "riskLevel": "medium"
    },
    "calculatedAt": "2025-01-15T10:30:00.000Z"
  },
  "meta": {
    "queryTimeMs": 156,
    "tier": "professional"
  },
  "rateLimit": {
    "limit": 50,
    "remaining": 49,
    "resetAt": "2025-01-16T00:00:00.000Z"
  }
}

curl -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"siteId": "10001", "reference": {"licenceNo": "1234567/1"}}' \
  "https://app.spectaura.com.au/api/v1/intermod"

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.example.com/api/v1?table=site&format=geojson&filter[state]=NSW"

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "id": "10001",
      "geometry": {
        "type": "Point",
        "coordinates": [151.209900, -33.865143]
      },
      "properties": {
        "site_id": "10001",
        "name": "Sydney Tower",
        "state": "NSW"
      }
    }
  ],
  "bbox": [150.5, -34.2, 152.0, -33.0],
  "metadata": {
    "success": true,
    "table": "site",
    "geometryColumn": "geom_4326",
    "featureCount": 150,
    "results": {
      "total": 150,
      "returned": 150,
      "truncated": false,
      "limit": -1
    },
    "queryTimeMs": 234,
    "rateLimit": { ... }
  }
}

curl -H "Authorization: Bearer YOUR_API_KEY" \
     -H "Accept: application/x-ndjson" \
  "https://api.example.com/api/v1?table=site&format=geojson"

{
  "success": false,
  "error": {
    "code": "INVALID_FILTER",
    "message": "Column 'foo' is not filterable",
    "details": {
      "field": "filter[foo]"
    }
  }
}

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.example.com/api/v1?table=site&filter[state][in]=NSW,VIC&limit=10"

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.example.com/api/v1?table=device_details&filter[frequency][between]=450000000,470000000&sort=frequency&order=asc"

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.example.com/api/v1?table=licence&filter[date_of_expiry][between]=2025-01-01,2025-06-30&sort=date_of_expiry"

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.example.com/api/v1?table=site&filter[state][ne]=NSW&limit=50"

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.example.com/api/v1?table=client_info&filter[licencee][ilike]=%some_licencee%"

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.example.com/api/v1?table=point_to_point_links&filter[client_no][eq]=12345&columns=a_site_id,b_site_id,distance_km,a_frequency"

import requests

API_KEY = "sk_live_your_api_key_here"
BASE_URL = "https://api.example.com/api/v1"

headers = {"Authorization": f"Bearer {API_KEY}"}

# Query sites in NSW
response = requests.get(
    BASE_URL,
    headers=headers,
    params={
        "table": "site",
        "filter[state][eq]": "NSW",
        "limit": 100
    }
)

data = response.json()
if data["success"]:
    for site in data["data"]:
        print(f"{site['site_id']}: {site['name']}")

    # Check rate limit
    remaining = data["rateLimit"]["remaining"]
    print(f"Requests remaining: {remaining}")

const API_KEY = "sk_live_your_api_key_here";
const BASE_URL = "https://api.example.com/api/v1";

async function querySites(state) {
  const params = new URLSearchParams({
    table: "site",
    "filter[state][eq]": state,
    limit: "100"
  });

  const response = await fetch(`${BASE_URL}?${params}`, {
    headers: { Authorization: `Bearer ${API_KEY}` }
  });

  const data = await response.json();

  if (!data.success) {
    throw new Error(`API Error: ${data.error.code} - ${data.error.message}`);
  }

  return data;
}

// Usage
const result = await querySites("VIC");
console.log(`Found ${result.pagination.total} sites`);

import requests
import geopandas as gpd
from io import StringIO

API_KEY = "sk_live_your_api_key_here"

# Fetch GeoJSON
response = requests.get(
    "https://api.example.com/api/v1",
    headers={"Authorization": f"Bearer {API_KEY}"},
    params={
        "table": "site",
        "format": "geojson",
        "filter[state][eq]": "NSW",
        "precision": 6
    }
)

# Load into GeoPandas
gdf = gpd.GeoDataFrame.from_features(response.json()["features"])
print(f"Loaded {len(gdf)} features")

# Save to file
gdf.to_file("nsw_sites.geojson", driver="GeoJSON")

import requests
import json

API_KEY = "sk_live_your_api_key_here"

# Stream large GeoJSON response
response = requests.get(
    "https://api.example.com/api/v1",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Accept": "application/x-ndjson"
    },
    params={"table": "site", "format": "geojson"},
    stream=True
)

features = []
for line in response.iter_lines():
    if line:
        obj = json.loads(line)
        if obj.get("type") == "Feature":
            features.append(obj)
        elif obj.get("type") == "footer":
            print(f"Query completed in {obj['queryTimeMs']}ms")

print(f"Processed {len(features)} features")

import requests

API_KEY = "sk_live_your_api_key_here"
BASE_URL = "https://api.example.com/api/v1"

def fetch_all(table, filters=None):
    """Fetch all records using pagination."""
    all_data = []
    page = 1
    limit = 1000

    while True:
        params = {"table": table, "page": page, "limit": limit}
        if filters:
            params.update(filters)

        response = requests.get(
            BASE_URL,
            headers={"Authorization": f"Bearer {API_KEY}"},
            params=params
        )

        data = response.json()
        if not data["success"]:
            raise Exception(f"Error: {data['error']['message']}")

        all_data.extend(data["data"])

        if not data["pagination"]["hasNext"]:
            break

        page += 1

    return all_data

# Fetch all Victorian licences
licences = fetch_all("licence", {"filter[state][eq]": "VIC"})
print(f"Total licences: {len(licences)}")