Anti-Fraud Infrastructure
for Governments
& Enterprises

# Get verification by ULID
curl -X GET "https://api.spatialproof.com/v1/verifications/01JXYZ1234567890ABCDEFGH" \
  -H "Authorization: Bearer sp_live_xxxxxxxxxxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json"

# Create a new project
curl -X POST "https://api.spatialproof.com/v1/projects" \
  -H "Authorization: Bearer sp_live_xxxxxxxxxxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "organization_id": "org_1234567890",
    "name": "Municipal Infrastructure Verification",
    "type": "reforestation",
    "collection_zones": [
      {
        "name": "Zone Alpha",
        "type": "polygon",
        "coordinates": [
          [-49.0661, -26.9194],
          [-49.0651, -26.9184],
          [-49.0641, -26.9194],
          [-49.0661, -26.9194]
        ]
      }
    ]
  }'

# Request a field collection
curl -X POST "https://api.spatialproof.com/v1/collections" \
  -H "Authorization: Bearer sp_live_xxxxxxxxxxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "project_id": "proj_987654321",
    "location": {
      "latitude": -26.9194,
      "longitude": -49.0661
    },
    "type": "road_repair_verification",
    "priority": "high"
  }'

import requests
import json

# Configuration
API_KEY = "sp_live_xxxxxxxxxxxxxxxxxxxxxxxx"
BASE_URL = "https://api.spatialproof.com/v1"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

# Get verification by ULID
def get_verification(ulid):
    response = requests.get(
        f"{BASE_URL}/verifications/{ulid}",
        headers=headers
    )
    return response.json()

# Create a new project
def create_project(project_data):
    response = requests.post(
        f"{BASE_URL}/projects",
        headers=headers,
        json=project_data
    )
    return response.json()

# Request field collection
def request_collection(project_id, lat, lng):
    data = {
        "project_id": project_id,
        "location": {
            "latitude": lat,
            "longitude": lng,
            "radius_meters": 50
        },
        "type": "road_repair_verification",
        "priority": "high"
    }
    response = requests.post(
        f"{BASE_URL}/collections",
        headers=headers,
        json=data
    )
    return response.json()

# Example usage
if __name__ == "__main__":
    # Get verification
    verification = get_verification("01JXYZ1234567890ABCDEFGH")
    print(f"Trust Score: {verification['verification']['ai_analysis']['overall_score']}")
    
    # Create project
    project = {
        "organization_id": "org_1234567890",
        "name": "Municipal Road Repair Verification",
        "type": "reforestation"
    }
    result = create_project(project)
    print(f"Project created: {result['project']['id']}")

// Configuration
const API_KEY = 'sp_live_xxxxxxxxxxxxxxxxxxxxxxxx';
const BASE_URL = 'https://api.spatialproof.com/v1';

const headers = {
  'Authorization': `Bearer ${API_KEY}`,
  'Content-Type': 'application/json'
};

// Get verification by ULID
async function getVerification(ulid) {
  const response = await fetch(`${BASE_URL}/verifications/${ulid}`, {
    method: 'GET',
    headers: headers
  });
  return await response.json();
}

// Create a new project
async function createProject(projectData) {
  const response = await fetch(`${BASE_URL}/projects`, {
    method: 'POST',
    headers: headers,
    body: JSON.stringify(projectData)
  });
  return await response.json();
}

// Request field collection
async function requestCollection(projectId, lat, lng) {
  const data = {
    project_id: projectId,
    location: {
      latitude: lat,
      longitude: lng,
      radius_meters: 50
    },
    type: 'road_repair_verification',
    priority: 'high',
    instructions: 'Capture BEFORE and AFTER photos of repair work'
  };
  
  const response = await fetch(`${BASE_URL}/collections`, {
    method: 'POST',
    headers: headers,
    body: JSON.stringify(data)
  });
  return await response.json();
}

// Example usage
(async () => {
  try {
    // Get verification
    const verification = await getVerification('01JXYZ1234567890ABCDEFGH');
    console.log('Trust Score:', verification.verification.ai_analysis.overall_score);
    
    // Create project with zones
    const project = {
      organization_id: 'org_1234567890',
      name: 'Municipal Road Repair Verification',
      type: 'public_works',
      collection_zones: [{
        name: 'Zone Alpha',
        type: 'polygon',
        coordinates: [
          [-49.0661, -26.9194],
          [-49.0651, -26.9184],
          [-49.0641, -26.9194],
          [-49.0661, -26.9194]
        ]
      }]
    };
    const result = await createProject(project);
    console.log('Project created:', result.project.id);
    
  } catch (error) {
    console.error('Error:', error);
  }
})();

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.google.gson.Gson;
import com.google.gson.JsonObject;

public class SpatialProofClient {
    private static final String API_KEY = "sp_live_xxxxxxxxxxxxxxxxxxxxxxxx";
    private static final String BASE_URL = "https://api.spatialproof.com/v1";
    private final HttpClient httpClient;
    private final Gson gson;
    
    public SpatialProofClient() {
        this.httpClient = HttpClient.newHttpClient();
        this.gson = new Gson();
    }
    
    // Get verification by ULID
    public JsonObject getVerification(String ulid) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/verifications/" + ulid))
            .header("Authorization", "Bearer " + API_KEY)
            .header("Content-Type", "application/json")
            .GET()
            .build();
            
        HttpResponse response = httpClient.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        return gson.fromJson(response.body(), JsonObject.class);
    }
    
    // Create a new project
    public JsonObject createProject(JsonObject projectData) throws Exception {
        String requestBody = gson.toJson(projectData);
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/projects"))
            .header("Authorization", "Bearer " + API_KEY)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(requestBody))
            .build();
            
        HttpResponse response = httpClient.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        return gson.fromJson(response.body(), JsonObject.class);
    }
    
    // Request field collection
    public JsonObject requestCollection(String projectId, double lat, double lng) throws Exception {
        JsonObject location = new JsonObject();
        location.addProperty("latitude", lat);
        location.addProperty("longitude", lng);
        location.addProperty("radius_meters", 50);
        
        JsonObject data = new JsonObject();
        data.addProperty("project_id", projectId);
        data.add("location", location);
        data.addProperty("type", "road_repair_verification");
        data.addProperty("priority", "high");
        
        String requestBody = gson.toJson(data);
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/collections"))
            .header("Authorization", "Bearer " + API_KEY)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(requestBody))
            .build();
            
        HttpResponse response = httpClient.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        return gson.fromJson(response.body(), JsonObject.class);
    }
    
    public static void main(String[] args) {
        try {
            SpatialProofClient client = new SpatialProofClient();
            
            // Get verification
            JsonObject verification = client.getVerification("01JXYZ1234567890ABCDEFGH");
            System.out.println("Trust Score: " + 
                verification.getAsJsonObject("verification")
                    .getAsJsonObject("ai_analysis")
                    .get("overall_score").getAsInt());
            
            // Create project
            JsonObject projectData = new JsonObject();
            projectData.addProperty("organization_id", "org_1234567890");
            projectData.addProperty("name", "Municipal Road Repair Verification");
            projectData.addProperty("type", "reforestation");
            
            JsonObject result = client.createProject(projectData);
            System.out.println("Project created: " + 
                result.getAsJsonObject("project").get("id").getAsString());
                
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

public class SpatialProofClient
{
    private const string ApiKey = "sp_live_xxxxxxxxxxxxxxxxxxxxxxxx";
    private const string BaseUrl = "https://api.spatialproof.com/v1";
    private readonly HttpClient httpClient;

    public SpatialProofClient()
    {
        httpClient = new HttpClient();
        httpClient.DefaultRequestHeaders.Authorization = 
            new AuthenticationHeaderValue("Bearer", ApiKey);
        httpClient.DefaultRequestHeaders.Accept.Add(
            new MediaTypeWithQualityHeaderValue("application/json"));
    }

    // Get verification by ULID
    public async Task<JObject> GetVerificationAsync(string ulid)
    {
        var response = await httpClient.GetAsync($"{BaseUrl}/verifications/{ulid}");
        response.EnsureSuccessStatusCode();
        var content = await response.Content.ReadAsStringAsync();
        return JObject.Parse(content);
    }

    // Create a new project
    public async Task<JObject> CreateProjectAsync(JObject projectData)
    {
        var json = JsonConvert.SerializeObject(projectData);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await httpClient.PostAsync($"{BaseUrl}/projects", content);
        response.EnsureSuccessStatusCode();
        var responseContent = await response.Content.ReadAsStringAsync();
        return JObject.Parse(responseContent);
    }

    // Request field collection
    public async Task<JObject> RequestCollectionAsync(
        string projectId, 
        double latitude, 
        double longitude)
    {
        var data = new JObject
        {
            ["project_id"] = projectId,
            ["location"] = new JObject
            {
                ["latitude"] = latitude,
                ["longitude"] = longitude,
                ["radius_meters"] = 50
            },
            ["type"] = "road_repair_verification",
            ["priority"] = "high",
            ["instructions"] = "Capture BEFORE and AFTER photos of repair work"
        };
        
        var json = JsonConvert.SerializeObject(data);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await httpClient.PostAsync($"{BaseUrl}/collections", content);
        response.EnsureSuccessStatusCode();
        var responseContent = await response.Content.ReadAsStringAsync();
        return JObject.Parse(responseContent);
    }

    public static async Task Main(string[] args)
    {
        var client = new SpatialProofClient();
        
        // Get verification
        var verification = await client.GetVerificationAsync("01JXYZ1234567890ABCDEFGH");
        Console.WriteLine($"Trust Score: {verification["verification"]["ai_analysis"]["overall_score"]}");
        
        // Create project
        var projectData = new JObject
        {
            ["organization_id"] = "org_1234567890",
            ["name"] = "Municipal Road Repair Verification",
            ["type"] = "reforestation"
        };
        
        var result = await client.CreateProjectAsync(projectData);
        Console.WriteLine($"Project created: {result["project"]["id"]}");
        
        // Request collection
        var collection = await client.RequestCollectionAsync(
            "proj_987654321", 
            -26.9194, 
            -49.0661
        );
        Console.WriteLine($"Collection requested: {collection["collection"]["id"]}");
    }
}

<?php

class SpatialProofClient {
    private const API_KEY = 'sp_live_xxxxxxxxxxxxxxxxxxxxxxxx';
    private const BASE_URL = 'https://api.spatialproof.com/v1';
    
    private $headers;
    
    public function __construct() {
        $this->headers = [
            'Authorization: Bearer ' . self::API_KEY,
            'Content-Type: application/json'
        ];
    }
    
    // Get verification by ULID
    public function getVerification($ulid) {
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, self::BASE_URL . "/verifications/{$ulid}");
        curl_setopt($ch, CURLOPT_HTTPHEADER, $this->headers);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        
        $response = curl_exec($ch);
        curl_close($ch);
        
        return json_decode($response, true);
    }
    
    // Create a new project
    public function createProject($projectData) {
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, self::BASE_URL . '/projects');
        curl_setopt($ch, CURLOPT_HTTPHEADER, $this->headers);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($projectData));
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        
        $response = curl_exec($ch);
        curl_close($ch);
        
        return json_decode($response, true);
    }
    
    // Request field collection
    public function requestCollection($projectId, $lat, $lng) {
        $data = [
            'project_id' => $projectId,
            'location' => [
                'latitude' => $lat,
                'longitude' => $lng,
                'radius_meters' => 50
            ],
            'type' => 'road_repair_verification',
            'priority' => 'high',
            'instructions' => 'Capture BEFORE and AFTER photos of repair work'
        ];
        
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, self::BASE_URL . '/collections');
        curl_setopt($ch, CURLOPT_HTTPHEADER, $this->headers);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        
        $response = curl_exec($ch);
        curl_close($ch);
        
        return json_decode($response, true);
    }
    
    // Create organization
    public function createOrganization($type, $name, $taxId, $country) {
        $data = [
            'type' => $type, // company, ngo, government
            'name' => $name,
            'tax_id' => $taxId,
            'country' => $country
        ];
        
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, self::BASE_URL . '/organizations');
        curl_setopt($ch, CURLOPT_HTTPHEADER, $this->headers);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        
        $response = curl_exec($ch);
        curl_close($ch);
        
        return json_decode($response, true);
    }
}

// Example usage
$client = new SpatialProofClient();

// Get verification
$verification = $client->getVerification('01JXYZ1234567890ABCDEFGH');
echo "Trust Score: " . $verification['verification']['ai_analysis']['overall_score'] . "\n";

// Create organization
$org = $client->createOrganization(
    'company',
    'City of São Paulo — Infrastructure Dept.',
    '48.468.140/0001-15',
    'BR'
);
echo "Organization created: " . $org['organization']['id'] . "\n";

// Create project
$projectData = [
    'organization_id' => 'org_1234567890',
    'name' => 'Municipal Road Repair Verification',
    'type' => 'public_works',
    'collection_zones' => [
        [
            'name' => 'Zone Alpha',
            'type' => 'polygon',
            'coordinates' => [
                [-49.0661, -26.9194],
                [-49.0651, -26.9184],
                [-49.0641, -26.9194],
                [-49.0661, -26.9194]
            ]
        ]
    ]
];

$project = $client->createProject($projectData);
echo "Project created: " . $project['project']['id'] . "\n";

// Request collection
$collection = $client->requestCollection(
    'proj_987654321', 
    -26.9194, 
    -49.0661
);
echo "Collection requested: " . $collection['collection']['id'] . "\n";

?>

require 'net/http'
require 'uri'
require 'json'

class SpatialProofClient
  API_KEY = 'sp_live_xxxxxxxxxxxxxxxxxxxxxxxx'
  BASE_URL = 'https://api.spatialproof.com/v1'
  
  def initialize
    @headers = {
      'Authorization' => "Bearer #{API_KEY}",
      'Content-Type' => 'application/json'
    }
  end
  
  # Get verification by ULID
  def get_verification(ulid)
    uri = URI("#{BASE_URL}/verifications/#{ulid}")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    
    request = Net::HTTP::Get.new(uri)
    @headers.each { |key, value| request[key] = value }
    
    response = http.request(request)
    JSON.parse(response.body)
  end
  
  # Create a new project
  def create_project(project_data)
    uri = URI("#{BASE_URL}/projects")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    
    request = Net::HTTP::Post.new(uri)
    @headers.each { |key, value| request[key] = value }
    request.body = project_data.to_json
    
    response = http.request(request)
    JSON.parse(response.body)
  end
  
  # Request field collection
  def request_collection(project_id, lat, lng)
    data = {
      'project_id' => project_id,
      'location' => {
        'latitude' => lat,
        'longitude' => lng,
        'radius_meters' => 50
      },
      'type' => 'road_repair_verification',
      'priority' => 'high',
      'instructions' => 'Capture BEFORE and AFTER photos of repair work'
    }
    
    uri = URI("#{BASE_URL}/collections")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    
    request = Net::HTTP::Post.new(uri)
    @headers.each { |key, value| request[key] = value }
    request.body = data.to_json
    
    response = http.request(request)
    JSON.parse(response.body)
  end
  
  # Create organization
  def create_organization(type, name, tax_id, country)
    data = {
      'type' => type, # government, company, ngo
      'name' => name,
      'tax_id' => tax_id,
      'country' => country
    }
    
    uri = URI("#{BASE_URL}/organizations")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    
    request = Net::HTTP::Post.new(uri)
    @headers.each { |key, value| request[key] = value }
    request.body = data.to_json
    
    response = http.request(request)
    JSON.parse(response.body)
  end
end

# Example usage
client = SpatialProofClient.new

# Get verification
verification = client.get_verification('01JXYZ1234567890ABCDEFGH')
puts "Trust Score: #{verification['verification']['ai_analysis']['overall_score']}"

# Create organization
org = client.create_organization(
  'company',
  'City of São Paulo — Infrastructure Dept.',
  '48.468.140/0001-15',
  'BR'
)
puts "Organization created: #{org['organization']['id']}"

# Create project
project_data = {
  'organization_id' => 'org_1234567890',
  'name' => 'Municipal Road Repair Verification',
  'type' => 'public_works',
  'collection_zones' => [
    {
      'name' => 'Zone Alpha',
      'type' => 'polygon',
      'coordinates' => [
        [-49.0661, -26.9194],
        [-49.0651, -26.9184],
        [-49.0641, -26.9194],
        [-49.0661, -26.9194]
      ]
    }
  ]
}

project = client.create_project(project_data)
puts "Project created: #{project['project']['id']}"

# Request collection
collection = client.request_collection(
  'proj_987654321',
  -26.9194,
  -49.0661
)
puts "Collection requested: #{collection['collection']['id']}"