Developer Docs

Two ways to integrate
physics-based verification

Choose hosted capture for fast pilots with zero mobile development, or embed our capture SDK into your app for full control. Both paths produce the same verified decision object.

Integration Models

Pick the path that fits your workflow

Recommended for pilots

Hosted Capture

Axiom handles the capture experience. Your system sends a request and gets a verified result. No mobile development required.

  • ✓No mobile SDK to embed
  • ✓Fastest time to pilot
  • ✓Axiom manages capture UX + retakes
  • ✓Results via API polling or webhook
  • ✓Field adjusters use Axiom's app

Embedded Capture SDK

Drop Axiom's capture SDK into your iOS or Android app. Your UI wraps our capture engine.

  • ✓iOS Swift Package + Android Kotlin SDK
  • ✓Full control over capture experience
  • ✓Direct access to camera preview + events
  • ✓Same verification pipeline
  • ✓Same signed package format

Model 1: Hosted Capture

Zero mobile development

Send an inspection request. Axiom sends a capture link to your field adjuster or customer. They capture using Axiom's app. You get a verified decision object via API.

How it works

1

Create an inspection request

Your server requests a capture session via the Axiom API, specifying the contact and requirements.

2

Adjuster receives a capture link

Axiom sends a secure link via SMS or email. The field adjuster opens Axiom's capture app. No login required.

3

Guided capture with quality gates

The app enforces motion excitation, lighting, and sensor requirements. Weak captures trigger immediate retake guidance.

4

Verified result returned

Axiom processes the signed capture package and returns a decision object (verified / rejected / unverified) to your server.

Server-side integration

import { Axiom, DuplicateReferenceError } from "@axiom-verify/sdk";

	const axiom = new Axiom({ apiKey: "axm_live_..." });

	// 1. Create an inspection request
	let inspection;
	try {
	  inspection = await axiom.createInspection({
	    type: "property_condition",
	    reference: "CLAIM-2024-001234",
	    contact: { email: "adjuster@example.com" },
	    requirements: { minDuration: 5, captureMode: "standard" },
	  });
	} catch (e) {
	  if (e instanceof DuplicateReferenceError) {
	    // Reference already exists (409). Decide whether to use the existing inspectionId
	    // or create a new reference and retry.
	    throw e;
	  }
	  throw e;
	}

	// 2. Share the capture link with the field adjuster
	console.log(inspection.captureLink);
	// → "https://axiomatize.org/capture/dGhpcyBpcyBh..."

// 3. Wait for the inspection to complete
const result = await axiom.waitForInspection(
  inspection.inspectionId,
  { onPoll: (r) => console.log(r.status) }
);

// result.status → "complete" | "expired"
// result.result → { status, checks, certificate }
// result.result.checks → { integrity, physics, attestation }

Model 2: Embedded Capture SDK

Your app, our capture engine

Embed Axiom's native capture SDK to control the experience. The SDK handles video recording, 200 Hz IMU sampling, ECDSA signing, Merkle tree construction, hardware attestation, and package bundling. Your app provides the UI.

import AxiomCapture

struct CaptureView: View {
    @StateObject private var capture = AxiomCapture()

    var body: some View {
        VStack {
            // Show camera preview
            CameraPreview(layer: capture.previewLayer)

            Text("\(capture.frameCount) frames, \(capture.imuSampleCount) IMU samples")

            Button(capture.isCapturing ? "Stop" : "Record") {
                if capture.isCapturing {
                    Task {
                        let result = try await capture.stopCapture()
                        // result.packageURL → VerificationPackage.zip
                        // Upload to your server → use Verify SDK
                    }
                } else {
                    capture.startCapture()
                }
            }
        }
        .task { try? await capture.setup() }
    }
}

What the SDK handles

Ultra-wide camera selection (no hardware OIS), EIS disable, 200 Hz IMU recording, ECDSA P-256 signing, Merkle-batched integrity chain, App Attest / Key Attestation.

What you build

Camera preview UI, record/stop controls, upload flow to your server. The SDK exposes a preview layer and lifecycle callbacks. You own the experience.

Installation

iOS: Add the Swift Package via SPM. Requires iOS 15+, physical device for App Attest.
Android: SDK in the app module. Requires API 31+, StrongBox preferred.

Server-Side: Verify SDK

Upload. Verify. Route.

Install the Verify SDK in your Node.js backend. Used in both integration models to submit capture packages and retrieve verification results.

npm install @axiom-verify/sdk
import { Axiom } from "@axiom-verify/sdk";

const axiom = new Axiom({ apiKey: "axm_live_..." });

// 1. Get a presigned upload URL
const upload = await axiom.createUpload();

// 2. Upload the capture package (ZIP with video + IMU + signatures)
const file = fs.readFileSync("capture_8f3k.zip");
await axiom.upload(upload, file);

// 3. Start verification
const job = await axiom.verify(upload.uploadId);

// 4. Wait for the result
const result = await axiom.waitForResult(job.jobId, {
  onPoll: (r) => console.log("status:", r.status),
});

// Result
console.log(result.status);      // "verified" | "rejected" | "unverified"
console.log(result.confidence);   // 0.0 – 1.0
console.log(result.reason);       // "verified_all_checks"
console.log(result.checks);       // { integrity, physics, attestation }
console.log(result.certificate);  // "axiom://cert/CERT-..."

Decision Semantics

Three verdicts. Zero ambiguity.

Every verification returns a machine-actionable routing decision, not a probability score. Each verdict maps to a specific workflow action.

verified

Capture is physically consistent with a real camera moving in a real scene. All integrity, physics, and attestation checks passed.

RouteFast-track to automation
rejected

High-confidence integrity violation detected. Reserved for cases where spoofing, recapture, or injection is the most plausible explanation.

RouteRecapture + QA review
unverified

Insufficient observability to decide without risk of false accusation. Reason codes prescribe the next step, never an accusation.

RouteGuided recapture

Response Format

The decision object

{
  "status": "verified",
  "confidence": 0.97,
  "reason": "verified_all_checks",
  "checks": {
    "integrity": {
      "status": "passed",
      "score": 1.0
    },
    "physics": {
      "status": "passed",
      "score": 0.97
    },
    "attestation": {
      "status": "passed",
      "score": 1.0
    }
  },
  "certificate": "axiom://cert/CERT-1707401234-a8f3"
}

checks.integrity

Layer 1: cryptographic binding. ECDSA signatures, Merkle tree recomputation, chain integrity. Proves the bundle was not tampered with after capture.

checks.physics

Layer 2: physics consistency. IMU-predicted motion vs visual optical flow. Detects screen recapture, injection, and motion-platform attacks.

checks.attestation

Layer 3: device attestation. Hardware-rooted key attestation via TEE/StrongBox (Android) and App Attest (iOS). Certificate chain validation against platform root CAs.

API Reference

Five endpoints

Verify API

POST
/v1/verify/upload

Generate a presigned upload URL. Returns uploadId, uploadUrl, and fields for S3 POST. Uploads expire in 15 minutes and are single-use.

POST
/v1/verify

Start a verification job. Accepts { uploadId } and returns { jobId, status: 'processing' }. Triggers the full pipeline: validate, verify signatures, physics check, generate certificate.

GET
/v1/verify/{jobId}

Get verification result. Returns the decision object with status, confidence, reason code, per-layer checks, and certificate URI. Poll until status is not 'processing'.

Inspections API

POST
/v1/inspections

Create an inspection request. Returns inspectionId, captureLink, and expiry. Capture links use 128-bit tokens and expire in 72 hours.

GET
/v1/inspections/{inspectionId}

Get inspection status and result. Returns status (pending → capturing → processing → complete), reference, and verification result when complete.

x-api-keyAll endpoints require an API key in the x-api-key header

Capture Package

What the capture SDK produces

Both integration models produce the same signed ZIP bundle containing synchronized video, IMU telemetry, and cryptographic evidence.

VerificationPackage.zip
├── video.mp4                  # H.264 video (ultra-wide, no OIS)
├── imu.leaves                 # Binary IMU samples (200 Hz)
│                              # 64 bytes each: timestamp + accel + gyro
├── siglog.jsonl               # Merkle-batched signature chain
├── attestation.cbor           # Hardware attestation (CBOR-encoded)
├── camera_metadata.jsonl      # Per-frame sensor timestamps + exposure
├── capture_metadata.json      # Device info, EIS/OIS flags
├── capture_mode.json          # IMU sample rate, lens selection
├── pubkey.pem                 # ECDSA public key
├── commit.bin                 # Commitment hash over all files
├── commit.sig                 # ECDSA signature over commitment
└── manifest.json              # File hashes + device metadata

Use Cases

Where it fits

Axiom works wherever a workflow depends on photo or video evidence and the cost of trusting fabricated media is high.

Insurance Claims

Protect straight-through processing from becoming a fraud magnet. Route captures to automation, review, or recapture based on physics, not probability.

Reduce LAE without increasing leakage

Auto Warranty

Verify vehicle location and condition at claim time. Detect screen recapture of stock photos and confirm VIN/odometer submissions are original captures.

Prevent fraudulent claims at intake

Construction Lending

Let borrowers self-inspect draw progress. Verify photos are taken at the project address and haven't been recycled from previous draws.

Fund draws in minutes, not days

Equipment Financing

Remotely confirm equipment condition and location throughout the lease period. Video evidence verified against physical presence.

Replace costly on-site inspections

Business Lending

Virtual site visits that carriers can trust. Verify business location, condition, and legitimacy without scheduling in-person inspections.

Win more business with faster turnaround

Product Recall

Validate proof of destruction and defect claims. Serial number extraction combined with capture integrity verification eliminates fake claims.

Cut logistics costs and false claims

How Axiom is Different

Not a detector. A verification control.

vs. Probabilistic detectors

Deepfake detectors output confidence scores that are hard to operationalize in liability-heavy workflows. Axiom returns routing decisions with explicit semantics, never a probability that someone has to interpret.

vs. Provenance standards (C2PA)

Content Credentials work when the chain is unbroken. In claims intake, that chain routinely breaks: heterogeneous devices, transcoding, vendor handoffs. Axiom produces a decision object that survives downstream handling.

vs. Secure capture platforms

Capture platforms verify metadata and flag AI-generated content. Axiom adds physics-constrained consistency checking between visual motion and device sensors, detecting screen recapture and injection attacks that metadata alone cannot catch.

Get API access

Request an API key and start integrating physics-based verification into your evidence workflow.

Request Access →Technical Spec