WildMap API

import requests

resp = requests.post(
    "https://<project>.supabase.co/functions/v1/api-keys",
    headers={
        "Authorization": "Bearer <supabase_jwt>",
        "Content-Type": "application/json",
    },
    json={
        "orgId": "your-org-uuid",
        "name": "Production Integration",
        "scopes": ["readings:read", "devices:read", "stream"],
        "expiresAt": "2027-01-01T00:00:00Z",
    }
)
api_key = resp.json()["key"]  # Store this securely — shown once only
print(f"API Key: {api_key}")

const resp = await fetch(
  "https://<project>.supabase.co/functions/v1/api-keys",
  {
    method: "POST",
    headers: {
      Authorization: "Bearer <supabase_jwt>",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      orgId: "your-org-uuid",
      name: "Production Integration",
      scopes: ["readings:read", "devices:read", "stream"],
      expiresAt: "2027-01-01T00:00:00Z",
    }),
  }
);
const { key } = await resp.json();
console.log(`API Key: ${key}`); // Store securely — shown once only

body := strings.NewReader(`{"orgId":"your-org-uuid","name":"Production Integration","scopes":["readings:read","devices:read","stream"],"expiresAt":"2027-01-01T00:00:00Z"}`)
req, _ := http.NewRequest("POST", "https://<project>.supabase.co/functions/v1/api-keys", body)
req.Header.Set("Authorization", "Bearer <supabase_jwt>")
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)
// Parse resp.Body for the "key" field — store securely

uri = URI("https://<project>.supabase.co/functions/v1/api-keys")
req = Net::HTTP::Post.new(uri, "Content-Type" => "application/json")
req["Authorization"] = "Bearer <supabase_jwt>"
req.body = { orgId: "your-org-uuid", name: "Production Integration",
             scopes: ["readings:read", "devices:read", "stream"],
             expiresAt: "2027-01-01T00:00:00Z" }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
api_key = JSON.parse(resp.body)["key"] # Store securely

resp = requests.get(
    f"{BASE}/api-readings",
    headers={"Authorization": f"Bearer {API_KEY}"},
    params={"start": "2026-03-01T00:00:00Z", "limit": 10, "order": "desc"}
)
for r in resp.json()["data"]:
    s = r["sensors"]
    print(f"{r['device']['serial']}: {s['temp_c']}°C, {s['wind_mps']} m/s")

const url = new URL(`${BASE}/api-readings`);
url.searchParams.set("start", "2026-03-01T00:00:00Z");
url.searchParams.set("limit", "10");
url.searchParams.set("order", "desc");

const resp = await fetch(url, {
  headers: { Authorization: `Bearer ${API_KEY}` }
});
const { data } = await resp.json();
data.forEach(r =>
  console.log(`${r.device.serial}: ${r.sensors.temp_c}°C, ${r.sensors.wind_mps} m/s`)
);

req, _ := http.NewRequest("GET",
    BASE+"/api-readings?start=2026-03-01T00:00:00Z&limit=10&order=desc", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

var result struct { Data []map[string]any }
json.NewDecoder(resp.Body).Decode(&result)
for _, r := range result.Data {
    fmt.Printf("%v: %v°C\n", r["device"], r["sensors"])
}

uri = URI("#{BASE}/api-readings?start=2026-03-01T00:00:00Z&limit=10&order=desc")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{API_KEY}"
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }

JSON.parse(resp.body)["data"].each do |r|
  s = r["sensors"]
  puts "#{r['device']['serial']}: #{s['temp_c']}°C, #{s['wind_mps']} m/s"
end

import requests, json

with requests.get(
    f"{BASE}/api-stream",
    headers={"Authorization": f"Bearer {API_KEY}"},
    stream=True
) as r:
    for line in r.iter_lines(decode_unicode=True):
        if line.startswith("data: "):
            reading = json.loads(line[6:])
            s = reading["sensors"]
            print(f"{reading['device']['serial']}: {s['temp_c']}°C")

const EventSource = require("eventsource");

const es = new EventSource(
  `${BASE}/api-stream`,
  { headers: { Authorization: `Bearer ${API_KEY}` } }
);

es.addEventListener("reading", (event) => {
  const r = JSON.parse(event.data);
  console.log(`${r.device.serial}: ${r.sensors.temp_c}°C`);
});

// Use github.com/r3labs/sse/v2
client := sse.NewClient(BASE + "/api-stream")
client.Headers["Authorization"] = "Bearer " + apiKey

client.SubscribeRaw(func(msg *sse.Event) {
    if string(msg.Event) == "reading" {
        fmt.Println(string(msg.Data))
    }
})

require "net/http"
require "json"

uri = URI("#{BASE}/api-stream")
Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
  req = Net::HTTP::Get.new(uri)
  req["Authorization"] = "Bearer #{API_KEY}"
  http.request(req) do |resp|
    resp.read_body do |chunk|
      chunk.each_line do |line|
        if line.start_with?("data: ")
          puts JSON.parse(line[6..])
        end
      end
    end
  end
end

requests.put(
    f"{BASE}/api-alert-thresholds",
    headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
    json={"parameter_path": "wind.speed.increaseMs", "value": 0.6}
)

await fetch(`${BASE}/api-alert-thresholds`, {
  method: "PUT",
  headers: { Authorization: `Bearer ${API_KEY}`, "Content-Type": "application/json" },
  body: JSON.stringify({ parameter_path: "wind.speed.increaseMs", value: 0.6 })
});

body := strings.NewReader(`{"parameter_path":"wind.speed.increaseMs","value":0.6}`)
req, _ := http.NewRequest("PUT", BASE+"/api-alert-thresholds", body)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
http.DefaultClient.Do(req)

uri = URI("#{BASE}/api-alert-thresholds")
req = Net::HTTP::Put.new(uri, "Content-Type" => "application/json")
req["Authorization"] = "Bearer #{API_KEY}"
req.body = { parameter_path: "wind.speed.increaseMs", value: 0.6 }.to_json
Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }

resp = requests.post(
    f"{BASE}/api-webhooks",
    headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
    json={"url": "https://your-server.com/wildmap-webhook",
          "events": ["new_reading", "alert_triggered"]}
)
secret = resp.json()["data"]["secret"]  # Store this — shown once only

const resp = await fetch(`${BASE}/api-webhooks`, {
  method: "POST",
  headers: { Authorization: `Bearer ${API_KEY}`, "Content-Type": "application/json" },
  body: JSON.stringify({
    url: "https://your-server.com/wildmap-webhook",
    events: ["new_reading", "alert_triggered"]
  })
});
const { data } = await resp.json();
console.log(`Secret: ${data.secret}`); // Store securely

body := strings.NewReader(`{"url":"https://your-server.com/wildmap-webhook","events":["new_reading","alert_triggered"]}`)
req, _ := http.NewRequest("POST", BASE+"/api-webhooks", body)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)
// Parse resp for data.secret — store securely

uri = URI("#{BASE}/api-webhooks")
req = Net::HTTP::Post.new(uri, "Content-Type" => "application/json")
req["Authorization"] = "Bearer #{API_KEY}"
req.body = { url: "https://your-server.com/wildmap-webhook",
             events: ["new_reading", "alert_triggered"] }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
secret = JSON.parse(resp.body)["data"]["secret"] # Store securely

import hmac, hashlib

def verify_signature(payload_bytes, signature, secret):
    expected = hmac.new(
        secret.encode(), payload_bytes, hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

const crypto = require("crypto");

function verifySignature(body, signature, secret) {
  const expected = crypto
    .createHmac("sha256", secret)
    .update(body)
    .digest("hex");
  return crypto.timingSafeEqual(
    Buffer.from(expected), Buffer.from(signature)
  );
}

func verifySignature(body []byte, signature, secret string) bool {
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write(body)
    expected := hex.EncodeToString(mac.Sum(nil))
    return hmac.Equal([]byte(expected), []byte(signature))
}

def verify_signature(payload, signature, secret)
  expected = OpenSSL::HMAC.hexdigest("SHA256", secret, payload)
  Rack::Utils.secure_compare(expected, signature)
end

import requests
from datetime import datetime, timedelta

API_KEY = "wf_your_key_here"
BASE = "https://<project>.supabase.co/functions/v1"
headers = {"Authorization": f"Bearer {API_KEY}"}

# Last 24 hours
since = (datetime.utcnow() - timedelta(hours=24)).isoformat() + "Z"
resp = requests.get(f"{BASE}/api-readings", headers=headers,
                    params={"start": since, "limit": 500})

for r in resp.json()["data"]:
    s = r["sensors"]
    print(f"{r['device']['serial']}: {s['temp_c']}°C, "
          f"{s['wind_mps']} m/s, PM2.5: {s['pm2_5']} µg/m³")

const API_KEY = "wf_your_key_here";
const BASE = "https://<project>.supabase.co/functions/v1";
const headers = { Authorization: `Bearer ${API_KEY}` };

// Last 24 hours
const since = new Date(Date.now() - 86400000).toISOString();
const resp = await fetch(
  `${BASE}/api-readings?start=${since}&limit=500`, { headers }
);
const { data } = await resp.json();

data.forEach(r => {
  const s = r.sensors;
  console.log(`${r.device.serial}: ${s.temp_c}°C, ${s.wind_mps} m/s, PM2.5: ${s.pm2_5}`);
});

package main

import (
    "encoding/json"; "fmt"; "net/http"; "time"
)

func main() {
    apiKey := "wf_your_key_here"
    base := "https://<project>.supabase.co/functions/v1"
    since := time.Now().Add(-24 * time.Hour).UTC().Format(time.RFC3339)

    req, _ := http.NewRequest("GET",
        fmt.Sprintf("%s/api-readings?start=%s&limit=500", base, since), nil)
    req.Header.Set("Authorization", "Bearer "+apiKey)
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    var result struct { Data []map[string]any }
    json.NewDecoder(resp.Body).Decode(&result)
    for _, r := range result.Data {
        fmt.Println(r)
    }
}

require "net/http"
require "json"
require "time"

API_KEY = "wf_your_key_here"
BASE = "https://<project>.supabase.co/functions/v1"

since = (Time.now.utc - 86400).strftime("%Y-%m-%dT%H:%M:%SZ")
uri = URI("#{BASE}/api-readings?start=#{since}&limit=500")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{API_KEY}"
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }

JSON.parse(resp.body)["data"].each do |r|
  s = r["sensors"]
  puts "#{r['device']['serial']}: #{s['temp_c']}°C, #{s['wind_mps']} m/s"
end