GetSitePlan.ai API

import time
import requests

TOKEN = "spf_your-token-here"
BASE = "https://getsiteplan.ai/api/v1"
HEADERS = {"Authorization": f"Bearer {TOKEN}"}

# Submit address
resp = requests.post(
    f"{BASE}/site-plan",
    headers=HEADERS,
    json={"address": "5811 Rose Ct, Countryside, IL"},
)
resp.raise_for_status()
job_id = resp.json()["job_id"]
print(f"Job submitted: {job_id}")

# Poll until ready
while True:
    resp = requests.get(f"{BASE}/site-plan/{job_id}", headers=HEADERS)
    data = resp.json()
    print(f"Status: {data['status']}")

    if data["status"] in ("ready", "failed"):
        break
    time.sleep(5)

# Download PDF
if data["status"] == "ready":
    pdf = requests.get(data["pdf_url"])
    with open("site-plan.pdf", "wb") as f:
        f.write(pdf.content)
    print("Downloaded: site-plan.pdf")

# Get GeoJSON features
features = requests.get(
    f"{BASE}/site-plan/{job_id}/features",
    headers=HEADERS,
).json()
print(f"Detected {len(features['features'])} features")

const TOKEN = "spf_your-token-here";
const BASE = "https://getsiteplan.ai/api/v1";
const headers = {
  Authorization: `Bearer ${TOKEN}`,
  "Content-Type": "application/json",
};

async function generateSitePlan(address) {
  // Submit address
  const submitResp = await fetch(`${BASE}/site-plan`, {
    method: "POST",
    headers,
    body: JSON.stringify({ address }),
  });
  const { job_id } = await submitResp.json();
  console.log(`Job submitted: ${job_id}`);

  // Poll until ready
  let data;
  while (true) {
    const statusResp = await fetch(`${BASE}/site-plan/${job_id}`, { headers });
    data = await statusResp.json();
    console.log(`Status: ${data.status}`);

    if (data.status === "ready" || data.status === "failed") break;
    await new Promise((r) => setTimeout(r, 5000));
  }

  // Download PDF
  if (data.status === "ready") {
    const pdf = await fetch(data.pdf_url);
    const blob = await pdf.blob();
    console.log(`PDF size: ${blob.size} bytes`);
  }

  // Get GeoJSON features
  const featResp = await fetch(`${BASE}/site-plan/${job_id}/features`, { headers });
  const features = await featResp.json();
  console.log(`Detected ${features.features.length} features`);

  return { data, features };
}

generateSitePlan("5811 Rose Ct, Countryside, IL");

const TOKEN = "spf_your-token-here";
const BASE = "https://getsiteplan.ai/api/v1";
const headers = {
  Authorization: `Bearer ${TOKEN}`,
  "Content-Type": "application/json",
};

// --- Response types ---

interface BalanceResponse {
  credits: number;
}

interface JobSubmitResponse {
  job_id: string;
  status: "processing";
}

interface JobStatusResponse {
  job_id: string;
  status: "pending" | "processing" | "ready" | "failed";
  pdf_url?: string;
  dxf_url?: string;
  error?: string;
}

type VehicleType = "sedan" | "suv" | "pickup" | "truck" | "unknown";

type DetectedCatalogType =
  | "tree" | "hedge" | "fence" | "pool" | "vehicle"
  | "structure" | "amenity" | "driveway" | "surface";

// AI-detected entities — always carry attrs + confidence + source.
interface DetectedFeatureProps {
  catalogType: DetectedCatalogType;
  attrs: Record<string, unknown>; // narrow on catalogType for typed access
  confidence: number;
  source: string;
  areaSqm?: number;
  sideId?: string;     // hedge, fence
  roadId?: string;     // driveway
  kind?: string;       // surface (patio | deck | walkway | hot_tub)
  headingDeg?: number; // vehicle
  parkedOn?: string;   // vehicle
}

// ?include=parcel — narrower shape, no attrs.
interface ParcelFeatureProps {
  catalogType: "parcel";
}

// ?include=building — rich variant when engine analysis is available;
// geometry-only fallback otherwise. attrs/confidence/source are all
// optional — narrow on their presence before reading.
interface BuildingFeatureProps {
  catalogType: "building";
  attrs?: Record<string, unknown>; // BuildingAttrs when present
  confidence?: number;
  source?: string;
}

type FeatureProps =
  | DetectedFeatureProps
  | ParcelFeatureProps
  | BuildingFeatureProps;

interface DetectedFeature {
  type: "Feature";
  geometry: { type: "Polygon"; coordinates: number[][][] };
  properties: FeatureProps;
}

interface FeatureCollection {
  type: "FeatureCollection";
  features: DetectedFeature[];
}

// --- API helpers ---

async function api<T>(path: string, init?: RequestInit): Promise<T> {
  const resp = await fetch(`${BASE}${path}`, { ...init, headers });
  if (!resp.ok) throw new Error(`API ${resp.status}: ${await resp.text()}`);
  return resp.json() as Promise<T>;
}

function sleep(ms: number): Promise<void> {
  return new Promise((r) => setTimeout(r, ms));
}

// --- Main workflow ---

async function generateSitePlan(address: string) {
  // Check balance
  const { credits } = await api<BalanceResponse>("/balance");
  console.log(`Credits: ${credits}`);

  // Submit address
  const { job_id } = await api<JobSubmitResponse>("/site-plan", {
    method: "POST",
    body: JSON.stringify({ address }),
  });
  console.log(`Job submitted: ${job_id}`);

  // Poll until ready
  let job: JobStatusResponse;
  do {
    await sleep(5000);
    job = await api<JobStatusResponse>(`/site-plan/${job_id}`);
    console.log(`Status: ${job.status}`);
  } while (job.status !== "ready" && job.status !== "failed");

  if (job.status === "failed") {
    throw new Error(`Job failed: ${job.error}`);
  }

  // Download PDF
  const pdf = await fetch(job.pdf_url!);
  const blob = await pdf.blob();
  console.log(`PDF: ${blob.size} bytes`);

  // Get GeoJSON features
  const fc = await api<FeatureCollection>(`/site-plan/${job_id}/features`);
  console.log(`Detected ${fc.features.length} features`);

  // Filter vehicles with body style
  const vehicles = fc.features.filter((f) => f.properties.catalogType === "vehicle");
  for (const v of vehicles) {
    const type = (v.properties.attrs as { type?: VehicleType }).type ?? "unknown";
    console.log(`  ${type} (${v.properties.confidence})`);
  }

  return { job, features: fc };
}

generateSitePlan("5811 Rose Ct, Countryside, IL");