# Bounties for agents Source: https://docs.vangrid.io/api/agent-bounties Commission a capture of a real place from software: pay the bounty in USDC on Base or Arc, a person films it, accept the result and receive the reconstruction. A bounty is a funded request for a capture of something specific: a loading dock, a station forecourt, a stock room. On the [bounty board](https://data.vangrid.io) people post them from a wallet. This API lets software do the same in one HTTP call: an agent pays the bounty amount through [x402](https://x402.org), Vangrid posts the bounty, a contributor goes there and films it, the agent reviews the submissions and accepts one. The escrow is released on chain and the reconstruction is delivered back through the same API. There is no account and no API key. The caller needs a wallet with USDC on Base or on Arc. ## Base URL ```text theme={"dark"} https://data.vangrid.io/api/v1 ``` ## How it works 1. `POST /bounties` with a title, a brief, the amount and a deadline. The server answers `402 Payment Required` quoting exactly the bounty amount in USDC. The client picks Base or Arc, signs the transfer and repeats the request; the transfer settles on that network before the request is processed. 2. The response carries a `bounty_id` and an `agent_token`. The token is the only credential for this bounty: keep it. 3. Within a minute the bounty is posted to the board from Vangrid's operator wallet, with your title and brief, and `onchain_id` and `board_url` appear in `GET /bounties/{id}`. 4. Contributors submit captures. Each one shows up under `submissions` with a short watermarked preview clip and a quality status. A person has to go and film, so this takes hours or days. 5. `POST /bounties/{id}/accept` with one `submission_id`. The escrow is released on chain, reconstruction starts, and the full capture and the 3D model become available on that submission. 6. Nothing worth accepting? `POST /bounties/{id}/cancel` while the bounty is open, or let the deadline pass. Either way the USDC is sent back to the wallet that paid. ## Endpoints | Method and path | Payment | Purpose | | - | - | - | | `POST /bounties` | the bounty amount, settled upfront | commission a capture | | `GET /bounties/{id}` | free, `Authorization: Bearer ` | status, submissions, model links | | `POST /bounties/{id}/accept` | free, bearer | accept one submission | | `POST /bounties/{id}/cancel` | free, bearer | cancel while open | ## Commission a capture ```text theme={"dark"} POST https://data.vangrid.io/api/v1/bounties ``` 3 to 200 characters. Shown on the board. 20 to 4000 characters. What to film, where exactly, what must be in frame, daylight or not. This is what the contributor reads. Whole USDC. This is the price of the call and the escrow of the bounty. The server quotes its current minimum and maximum in the discovery metadata; the defaults are 50 and 5000. 1 to 30. Defaults to `7`. A submission can be accepted until the deadline; after it the escrow is refunded. A malformed request is answered with `400` before any price is quoted. ### Example ```javascript theme={"dark"} import { wrapFetchWithPaymentFromConfig } from "@x402/fetch"; import { ExactEvmScheme } from "@x402/evm/exact/client"; import { privateKeyToAccount } from "viem/accounts"; const account = privateKeyToAccount(process.env.EVM_PRIVATE_KEY); const fetchWithPayment = wrapFetchWithPaymentFromConfig(fetch, { // "eip155:8453" pays on Base; "eip155:5042" pays on Arc (see Supported networks) schemes: [{ network: "eip155:8453", client: new ExactEvmScheme(account) }], spendControls: { maxAmountPerPayment: "$500" }, }); const res = await fetchWithPayment("https://data.vangrid.io/api/v1/bounties", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ title: "Loading dock, east side", brief: "Walk the full length of the east loading dock at ground level, both directions, daylight. Include the ramp and the two roller doors.", amount_usdc: 200, deadline_days: 7, }), }); const bounty = await res.json(); ``` ```json theme={"dark"} { "bounty_id": "cmufahx1e00002egi0d1um822", "status": "paid", "amount_usdc": 200, "deadline": "2026-10-01T08:48:24.000Z", "title": "Loading dock, east side", "onchain_id": null, "board_url": null, "payer": "0x7bab81f94ce1548bb9ecddaf3945fb65d95a49a7", "payment_tx": "0x…", "poll_url": "https://data.vangrid.io/api/v1/bounties/cmufahx1e00002egi0d1um822", "agent_token": "vgb_…" } ``` `agent_token` is returned once. Send it as `Authorization: Bearer vgb_…` on the other three calls. ## Status and submissions ```text theme={"dark"} GET https://data.vangrid.io/api/v1/bounties/{id} ``` `paid` (payment received), `open` (posted on the board), `accepting`, `accepted`, `cancelling`, `cancelled`, `expired`, `expired_refunded`, `failed`. Id of the bounty in the escrow contract, once posted. `board_url` links to it on the board. The network you paid on, `eip155:8453` (Base) or `eip155:5042` (Arc). Refunds return there. Transactions for each step. `payout_tx` is the USDC transfer back to `payer` after a cancel or an expiry, on the network you paid on. Use it in the accept call. ISO 8601. The contributor's note, if any. A short watermarked clip, valid for 15 minutes. Fetch the status again for a fresh link. Automated check: `pending`, `pass`, `fail`. `none` until accepted, then `queued`, `running`, `ready` or `failed`. Present on the accepted submission only, once each file exists. Signed links, valid for 15 minutes. ## Accept and cancel ```text theme={"dark"} POST https://data.vangrid.io/api/v1/bounties/{id}/accept { "submission_id": "…" } ``` Allowed while the bounty is `open` and before the deadline. Answers `202` and the status moves to `accepting`, then `accepted` once the release is confirmed on chain. Accepting is final. ```text theme={"dark"} POST https://data.vangrid.io/api/v1/bounties/{id}/cancel ``` Allowed while the bounty is `open`. The escrow is withdrawn on chain and the USDC is transferred to `payer`; the status ends at `cancelled` with `payout_tx` set. After the deadline the same happens without a call: `expired_refunded`. ## Supported networks | Network | CAIP-2 | USDC | | - | - | - | | Base | `eip155:8453` | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` | | Arc | `eip155:5042` | `0x3600000000000000000000000000000000000000` | The 402 quote lists both; pay on whichever one you hold USDC on. Refunds return on the network you paid on. Arc's USDC has to be allowed once in the client, see [Pay per request](/api/pay-per-request#supported-networks). ## Money The amount you pay is the amount escrowed in the bounty contract, posted from Vangrid's operator wallet on your behalf. Contributors are paid by Vangrid on acceptance under the same terms as any other bounty on the board. Refunds go to the wallet that paid, in full, on cancel or expiry. The escrow sits on the network you paid on: a bounty paid on Arc is escrowed in the Arc contract, one paid on Base in the Base contract. The board lists both. ## Use it from an agent The [Vangrid MCP server](https://github.com/vangrid-labs/bounty-mcp) exposes this flow as four tools: `vangrid_post_bounty`, `vangrid_bounty_status`, `vangrid_accept_submission`, `vangrid_cancel_bounty`. It keeps the bounty token locally, so after posting the agent only needs the `bounty_id`. Setup is the same as for the data tools, see [Pay per request](/api/pay-per-request); set `MAX_USD_PER_BOUNTY` to cap what a single bounty may cost. ## Errors | Status | Error code | Description | | - | - | - | | `400` | `invalid_request` | a field is missing or out of range; `field` names it | | `401` | `unauthorized` | bounty id and token do not match | | `402` | `payment_required` | no payment, or the transfer could not be settled | | `404` | `not_found` | no such submission on this bounty | | `409` | `not_open` | the bounty is not open (already accepting, accepted, cancelled or expired) | | `409` | `deadline_passed` | too late to accept; the escrow will be refunded | # Authentication Source: https://docs.vangrid.io/api/authentication Bearer API keys, region scoping, and how to handle credential errors. The API is in early access and is not publicly available. Endpoint URLs, request examples and sample responses on this page are illustrative. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request access. Every request to the Vangrid API must include your API key as a Bearer token in the `Authorization` header. Requests without a valid key return `401 Unauthorized` and are not processed. ## Obtaining your API key Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request API access. Once your account is provisioned, your API key is available in the Vangrid dashboard under **Settings → API Keys**. ## Passing your API key Include your key in the `Authorization` header on every request: ```text theme={"dark"} Authorization: Bearer your-api-key ``` ```bash curl theme={"dark"} curl -X POST https://api.vangrid.io/v1/spatial/query \ -H "Authorization: Bearer your-api-key" \ -H "Content-Type: application/json" \ -d '{"aoi": {"type": "Point", "coordinates": [-122.4194, 37.7749]}}' ``` ```python Python theme={"dark"} import requests response = requests.post( "https://api.vangrid.io/v1/spatial/query", headers={"Authorization": "Bearer your-api-key"}, json={"aoi": {"type": "Point", "coordinates": [-122.4194, 37.7749]}} ) ``` ```javascript JavaScript theme={"dark"} const response = await fetch("https://api.vangrid.io/v1/spatial/query", { method: "POST", headers: { "Authorization": "Bearer your-api-key", "Content-Type": "application/json" }, body: JSON.stringify({ aoi: { type: "Point", coordinates: [-122.4194, 37.7749] } }) }); ``` ## Authentication errors | HTTP status | Error code | Cause | | - | - | - | | `401` | `unauthorized` | Key is missing, malformed, or revoked | | `403` | `region_not_authorized` | Key is valid but not authorized for the requested region | Example `401` response: ```json theme={"dark"} { "error": "unauthorized", "message": "Invalid or missing API key. Include your key as Authorization: Bearer ." } ``` ## Best practices Never hard-code your API key in source code or commit it to version control. * Store your key in an environment variable: `VANGRID_API_KEY` * Use separate keys for development and production environments * Rotate keys periodically via the dashboard * Revoke compromised keys immediately from **Settings → API Keys** If you suspect a key has been exposed, revoke it in the dashboard and issue a new one before updating your application config. # Data ingestion Source: https://docs.vangrid.io/api/data-ingestion POST /v1/ingest. Submit your own observations and receive a provenance record. The API is in early access and is not publicly available. Endpoint URLs, request examples and sample responses on this page are illustrative. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request access. The data ingestion endpoint accepts raw video footage from your sensor systems. **You do not submit observations directly**, Vangrid's pipeline ingests the video and extracts spatial observations (objects, vehicles, structures, etc.) automatically. The resulting observations are processed through the same cryptographic provenance pipeline as native edge node data. Observations are an output of Vangrid's pipeline, not an input. Send video; Vangrid handles the rest. ## How it works 1. **You submit video**, Upload a raw video clip from your sensor (drone, fixed camera, vehicle-mounted, etc.) 2. **Vangrid processes it**, The pipeline runs perception, georeferencing, and quality checks on the footage 3. **Observations are extracted**, Spatial observations (geometry, type, confidence) are produced and committed to the network 4. **You receive provenance records**, Each extracted observation gets a `provenance_hash` you can use to verify integrity later ## Endpoint ```text theme={"dark"} POST https://api.vangrid.io/v1/ingest ``` ## Request ### Headers | Header | Value | | - | - | | `Authorization` | `Bearer your-api-key` | | `Content-Type` | `multipart/form-data` | ### Body parameters Raw video file from your sensor. Supported formats: `mp4`, `mov`, `avi`. Maximum file size: 2 GB. Your internal sensor identifier. Stored with the provenance record for every observation extracted from this video. ISO 8601 UTC timestamp of when the video capture began. Optional GeoJSON Point indicating the approximate capture location. Helps the pipeline georeferencing step if GPS metadata is missing from the video file. ### Example request ```bash theme={"dark"} curl -X POST https://api.vangrid.io/v1/ingest \ -H "Authorization: Bearer your-api-key" \ -F "video=@/path/to/footage.mp4" \ -F "sensor_id=drone-unit-07" \ -F "captured_at=2026-05-22T10:14:30.000Z" \ -F 'location_hint={"type":"Point","coordinates":[-122.4150,37.7800]}' ``` ## Response Once the video is accepted, Vangrid returns an `ingestion_id` you can use to track processing status. Observations are **not immediately available**, pipeline processing typically takes 30–120 seconds depending on video length. ### Response fields Unique identifier for this ingestion job. Use this to poll processing status. Current pipeline status. One of: `queued`, `processing`, `complete`, `failed`. ISO 8601 UTC timestamp of estimated processing completion. ### Example response ```json theme={"dark"} { "ingestion_id": "ing_7c4d1e8b", "status": "queued", "estimated_completion": "2026-05-22T10:16:00.000Z" } ``` Once processing is `complete`, the extracted observations are available via the [spatial query endpoint](/api/spatial-queries) and include `provenance_hash` values you can verify using the [provenance verification endpoint](/data/cryptographic-provenance). ## Error responses | Status | Error code | Description | | - | - | - | | `400` | `unsupported_format` | Video format not supported | | `400` | `missing_timestamp` | `captured_at` is required | | `400` | `file_too_large` | Video exceeds 2 GB limit | | `401` | `unauthorized` | Missing or invalid API key | | `429` | `rate_limit_exceeded` | Too many requests | # API overview Source: https://docs.vangrid.io/api/overview The Enterprise Spatial API: query, ingest, stream and verify. The API is in early access and is not publicly available. Endpoint URLs, request examples and sample responses on this page are illustrative. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request access. The Vangrid Enterprise Spatial API is a REST API that exposes the full power of the Vangrid edge network to your applications. Use it to query real-time spatial observations for any area of interest, ingest data from your own sensors, and subscribe to live ground truth streams. ## Base URL All API requests are made to: ```text theme={"dark"} https://api.vangrid.io/v1 ``` ## Authentication Every request requires a Bearer token in the `Authorization` header: ```text theme={"dark"} Authorization: Bearer your-api-key ``` See [API Authentication](/api/authentication) for details on obtaining and managing your API key. ## Request and response format All request bodies and responses use JSON. Set `Content-Type: application/json` on requests with a body. Successful responses return HTTP `200` with a JSON body. Errors return the appropriate HTTP status code and a JSON error object: ```json theme={"dark"} { "error": "error_code", "message": "Human-readable description of the error." } ``` ## Rate limits Rate limits depend on your plan tier. The current limit is included in every response via headers: | Header | Description | | - | - | | `X-RateLimit-Limit` | Maximum requests per minute | | `X-RateLimit-Remaining` | Requests remaining in the current window | | `X-RateLimit-Reset` | Unix timestamp when the window resets | When you exceed your rate limit, the API returns `429 Too Many Requests`. ## Endpoints Query ground truth observations for a geographic area of interest. Submit observations from your own sensors into the Vangrid network. Subscribe to real-time ground truth updates for a defined zone. Manage API keys and understand authentication requirements. ## Common error codes | Code | HTTP status | Meaning | | - | - | - | | `unauthorized` | 401 | Missing or invalid API key | | `region_not_authorized` | 403 | AOI outside your authorized regions | | `invalid_geometry` | 400 | Malformed GeoJSON in request | | `aoi_too_large` | 400 | Area of interest exceeds maximum size | | `rate_limit_exceeded` | 429 | Too many requests | | `internal_error` | 500 | Unexpected server error, contact support | To request access or upgrade your plan, contact [hello@vangrid.io](mailto:hello@vangrid.io). # Pay per request Source: https://docs.vangrid.io/api/pay-per-request Anchored capture data for agents, paid per call in USDC on Base or Arc with x402. No account, no API key. The pay per request API serves captures that are already attested on Base. Each call is paid on the spot in USDC through [x402](https://x402.org), an open payment standard built on HTTP status 402. There is no sign up, no API key and no invoice: the caller holds a wallet with USDC on Base or on Arc, the client library signs a transfer for the quoted price, and the response comes back in the same request. The API is built for software that acts on its own: agents, pipelines, MCP tools. A person can use it too, with the same client. ## Base URL ```text theme={"dark"} https://data.vangrid.io/api/v1 ``` ## How a paid call works 1. The client sends the request without payment. 2. The server answers `402 Payment Required` with a `PAYMENT-REQUIRED` header: price, asset (USDC), the supported networks and the receiving address. 3. The client picks a network, signs a USDC transfer authorization for that amount and repeats the request with a `PAYMENT-SIGNATURE` header. 4. The server verifies the signature, returns the data, and the transfer settles on the network the client chose. The `PAYMENT-RESPONSE` header carries the transaction. x402 client libraries do steps 2 to 4 automatically. The wallet needs USDC only; gas is covered by the settlement service. ## Supported networks Base and Arc. Every paid call is quoted on both at once; the client pays on the one it holds USDC on. | Network | CAIP-2 | USDC | Notes | | - | - | - | - | | Base | `eip155:8453` | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` | default in every x402 client | | Arc | `eip155:5042` | `0x3600000000000000000000000000000000000000` | USDC is Arc's native asset behind an ERC-20 predeploy; settlement is final at once | Arc is not in the x402 client libraries' default asset table, so a buyer that wants to pay on Arc allows the asset once: ```javascript theme={"dark"} const fetchWithPayment = wrapFetchWithPaymentFromConfig(fetch, { schemes: [{ network: "eip155:5042", client: new ExactEvmScheme(account) }], spendControls: { allowedAssets: [{ network: "eip155:5042", asset: "0x3600000000000000000000000000000000000000", maxAmountPerPayment: "50000" }], }, }); ``` ## Endpoints | Method and path | Price | Returns | | - | - | - | | `POST /spatial/query` | \$0.01 | Observations inside an area of interest and time window | | `GET /observations/{id}` | \$0.005 | One observation by its sha256 | | `GET /provenance/{hash}` | free | Whether a sha256 is an attested capture, and where it is anchored | Prices are quoted by the server on every request and can change. A client library reads the quote and never pays more than the cap you configure. ## Observation object Every paid endpoint returns observations in this shape. The sha256 of the capture, hex. Also the id for `GET /observations/{id}`. `sha256:` followed by the observation id. Coarse location as attested: a geohash of six characters, a cell of about 1.2 km by 0.6 km. Nothing finer is served. ISO 8601 UTC time of capture. The Merkle tree that contains this capture and its attestation on Base. `8453`, Base. Tree number in the explorer. Hash of this capture's leaf in the tree. Merkle root that was attested. EAS attestation uid on Base. Transaction that wrote the attestation. The attestation on base.easscan.org. The tree on explorer.vangrid.io. Responses contain no wallet addresses, no media and no network wide counts. ## Spatial query ```text theme={"dark"} POST https://data.vangrid.io/api/v1/spatial/query ``` GeoJSON geometry. `Point` with `radius_m`, or `Polygon` whose bounding box is at most 100 km². For a `Point`: radius in metres, 1 to 5000. Defaults to `500`. ISO 8601 start of the time window. Defaults to seven days before `to`. ISO 8601 end of the time window. Defaults to now. Maximum observations to return, 1 to 1000. Defaults to `100`. Results are ordered newest first. ### Example ```javascript theme={"dark"} import { wrapFetchWithPaymentFromConfig } from "@x402/fetch"; import { ExactEvmScheme } from "@x402/evm/exact/client"; import { privateKeyToAccount } from "viem/accounts"; const account = privateKeyToAccount(process.env.EVM_PRIVATE_KEY); const fetchWithPayment = wrapFetchWithPaymentFromConfig(fetch, { // "eip155:8453" pays on Base; "eip155:5042" pays on Arc (see Supported networks) schemes: [{ network: "eip155:8453", client: new ExactEvmScheme(account) }], spendControls: { maxAmountPerPayment: "$0.05" }, }); const res = await fetchWithPayment("https://data.vangrid.io/api/v1/spatial/query", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ aoi: { type: "Point", coordinates: [139.7671, 35.6812] }, radius_m: 1000, from: "2026-09-17T00:00:00Z", to: "2026-09-24T00:00:00Z", }), }); const { observations } = await res.json(); ``` ```json theme={"dark"} { "window": { "from": "2026-09-17T00:00:00.000Z", "to": "2026-09-24T00:00:00.000Z" }, "observations": [ { "observation_id": "cf9642dae244a213bc9c0e6d325a84be44fe8fd1f57d9b362c64493769b74a48", "provenance_hash": "sha256:cf9642dae244a213bc9c0e6d325a84be44fe8fd1f57d9b362c64493769b74a48", "geohash": "xn76e4", "captured_at": "2026-09-24T06:31:34.000Z", "anchor": { "chain_id": 8453, "tree_id": 4145, "leaf_hash": "0x25b77cf9b580c39dd49561efb23bf6903755df5d02330f10eb09d6f9aa79596e", "root": "0x6deec66f4ef88662b3c784782bce696e99dc9ff518363eeefe76c0760d69f221", "attest_uid": "0x1b0a4d4221b2721f6386abf40787dc06690ad781e877e64db98db9e49ddbd9df", "attest_tx": "0xd41521271ac64fe72db3cf3a667b4cd7e05c47429b46e2d145f3d8ce63e6e706", "eas_url": "https://base.easscan.org/attestation/view/0x1b0a4d4221b2721f6386abf40787dc06690ad781e877e64db98db9e49ddbd9df", "viewer_url": "https://explorer.vangrid.io/tree/4145" } } ] } ``` An empty area returns `200` with an empty `observations` array. ## Observation by id ```text theme={"dark"} GET https://data.vangrid.io/api/v1/observations/{id} ``` `id` is the sha256 of the capture, with or without the `0x` prefix. Returns one observation object, or `404` when no attested capture has this id. ## Provenance check ```text theme={"dark"} GET https://data.vangrid.io/api/v1/provenance/{hash} ``` Free. Answers whether a sha256 is a capture attested by Vangrid on Base. ```bash theme={"dark"} curl https://data.vangrid.io/api/v1/provenance/cf9642dae244a213bc9c0e6d325a84be44fe8fd1f57d9b362c64493769b74a48 ``` ```json theme={"dark"} { "provenance_hash": "sha256:cf9642dae244a213bc9c0e6d325a84be44fe8fd1f57d9b362c64493769b74a48", "verified": true, "captured_at": "2026-09-24T06:31:34.000Z", "geohash": "xn76e4", "anchor": { "chain_id": 8453, "tree_id": 4145, "attest_uid": "0x1b0a…d9df", "attest_tx": "0xd415…e706" } } ``` An unknown hash returns `200` with `"verified": false`. To check independently, open `anchor.eas_url`: the attestation is written by Vangrid's attester and references the tree at `viewer_url`, where the leaf and its Merkle path are listed. ## Use it from an agent The service describes itself for agents: an OpenAPI document at `https://data.vangrid.io/openapi.json` and an x402 manifest at `https://data.vangrid.io/.well-known/x402`, with the price, the networks and the request schema of every paid endpoint. For Claude, Cursor and other MCP clients, Vangrid ships an open source MCP server: [github.com/vangrid-labs/bounty-mcp](https://github.com/vangrid-labs/bounty-mcp) (MIT). It exposes these calls and [bounties for agents](/api/agent-bounties) as tools and pays from the agent's own wallet, with a spending cap per call and per bounty. Node 20 or newer; the MCP client fetches the server from GitHub on first run. Claude Desktop (`claude_desktop_config.json`) or Cursor (`.cursor/mcp.json`): ```json theme={"dark"} { "mcpServers": { "vangrid": { "command": "npx", "args": ["-y", "github:vangrid-labs/bounty-mcp"], "env": { "VANGRID_API_URL": "https://data.vangrid.io", "X402_NETWORK": "auto", "EVM_PRIVATE_KEY": "0x...", "MAX_USD_PER_CALL": "0.05", "MAX_USD_PER_BOUNTY": "100" } } } } ``` Claude Code: ```bash theme={"dark"} claude mcp add vangrid -e EVM_PRIVATE_KEY=0x... -- npx -y github:vangrid-labs/bounty-mcp ``` `X402_NETWORK=auto` pays on whichever of Base and Arc holds more USDC for the wallet; `eip155:8453` or `eip155:5042` fixes the network. Use a fresh wallet that holds only what the agent may spend. The repository README covers creating and funding it. Data tools: `vangrid_coverage_query`, `vangrid_observation`, `vangrid_verify_provenance`. Without a key the server runs in read only mode and the free tool still works. ## Errors | Status | Error code | Description | | - | - | - | | `400` | `invalid_geometry` | `aoi` is not a supported GeoJSON geometry | | `400` | `aoi_too_large` | Bounding box of the polygon exceeds 100 km² | | `400` | `invalid_request` | A date, limit or id is malformed | | `402` | `payment_required` | No payment, or the payment could not be verified | | `404` | `not_found` | No attested capture with this id | ## Related Need a place captured that is not in the index yet? [Bounties for agents](/api/agent-bounties) lets software commission a capture the same way: pay the bounty in USDC, a person films it, accept the result. The [Enterprise Spatial API](/api/overview) covers commissioned capture, ingestion, streaming and region scoped access under an agreement. Pay per request is the open door: the same anchored data, one call at a time. # Spatial queries Source: https://docs.vangrid.io/api/spatial-queries POST /v1/spatial/query. Send an area of interest and a time window, receive verified observations. The API is in early access and is not publicly available. Endpoint URLs, request examples and sample responses on this page are illustrative. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request access. The spatial query endpoint returns current ground truth observations from Vangrid edge nodes within your specified area of interest (AOI). Use it to retrieve verified spatial intelligence on demand for any authorized geographic region. ## Endpoint ```text theme={"dark"} POST https://api.vangrid.io/v1/spatial/query ``` ## Request ### Headers | Header | Value | | - | - | | `Authorization` | `Bearer your-api-key` | | `Content-Type` | `application/json` | ### Body parameters GeoJSON geometry defining the area of interest. Supports `Point`, `Polygon`, and `MultiPolygon` types. Maximum polygon area is 100 km². Minimum ground truth confidence score (0.0–1.0). Observations below this threshold are excluded. Defaults to `0.5`. Filter by observation type. Possible values: `obstacle`, `occupancy`, `change`, `structure`, `vehicle`, `vegetation`. If omitted, all types are returned. Maximum age of observations in seconds. Defaults to `60`. Use `0` for observations captured within the last second only. Maximum number of observations to return. Defaults to `100`, maximum `1000`. ### Example request ```bash theme={"dark"} curl -X POST https://api.vangrid.io/v1/spatial/query \ -H "Authorization: Bearer your-api-key" \ -H "Content-Type: application/json" \ -d '{ "aoi": { "type": "Polygon", "coordinates": [[ [-122.4194, 37.7749], [-122.4094, 37.7749], [-122.4094, 37.7849], [-122.4194, 37.7849], [-122.4194, 37.7749] ]] }, "min_ground_truth_score": 0.75, "observation_types": ["obstacle", "vehicle"], "max_age_seconds": 30, "limit": 50 }' ``` ## Response ### Response fields Unique identifier for this query, useful for support requests. Number of edge nodes that contributed observations to this response. Array of ground truth observation objects. Unique identifier for this observation. GeoJSON geometry of the observed feature. Classification of the observation. Confidence score from 0.0 to 1.0. ISO 8601 UTC timestamp of capture. Cryptographic proof of data origin. Number of nodes that corroborated this observation. ### Example response ```json theme={"dark"} { "query_id": "qry_9e2f1a7c", "node_count": 47, "observations": [ { "observation_id": "obs_3b8d2f1a", "geometry": { "type": "Point", "coordinates": [-122.4150, 37.7800] }, "observation_type": "vehicle", "ground_truth_score": 0.94, "timestamp": "2026-05-22T10:14:33.412Z", "provenance_hash": "sha256:a3f8e2c1b4d7f9e0a2b5c8d1e4f7a0b3c6d9e2f5", "node_count": 12 } ] } ``` ## Error responses | Status | Error code | Description | | - | - | - | | `400` | `invalid_geometry` | AOI is not valid GeoJSON | | `400` | `aoi_too_large` | AOI polygon exceeds 100 km² | | `401` | `unauthorized` | Missing or invalid API key | | `403` | `region_not_authorized` | AOI outside authorized regions | | `429` | `rate_limit_exceeded` | Too many requests | # Streaming Source: https://docs.vangrid.io/api/streaming POST /v1/spatial/stream. Subscribe to a push feed of observations for an area. The API is in early access and is not publicly available. Endpoint URLs, request examples and sample responses on this page are illustrative. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request access. The Vangrid Streaming API delivers a continuous, real-time feed of ground truth events for a geographic zone you define. Unlike polling the spatial query endpoint, streaming gives you push-based updates the moment new observations are available from the edge network, essential for autonomous systems, live monitoring dashboards, and world model pipelines. ## Endpoint ```text theme={"dark"} POST https://api.vangrid.io/v1/spatial/stream ``` The connection stays open and the server pushes newline-delimited JSON (`\n`) events as they arrive. The client reads the response body as a stream. ## Request ### Headers | Header | Value | | - | - | | `Authorization` | `Bearer your-api-key` | | `Content-Type` | `application/json` | ### Body parameters GeoJSON geometry defining the zone to monitor. Supports `Polygon` and `MultiPolygon`. Maximum area is 50 km². Filter events to those above this confidence threshold. Defaults to `0.5`. Limit events to specific observation types. If omitted, all types are streamed. ### Example, open a stream ```bash curl theme={"dark"} curl -X POST https://api.vangrid.io/v1/spatial/stream \ -H "Authorization: Bearer your-api-key" \ -H "Content-Type: application/json" \ -d '{ "aoi": { "type": "Polygon", "coordinates": [[ [-122.4194, 37.7749], [-122.4094, 37.7749], [-122.4094, 37.7849], [-122.4194, 37.7849], [-122.4194, 37.7749] ]] }, "min_ground_truth_score": 0.75 }' ``` ```python Python theme={"dark"} import requests import json API_KEY = "your-api-key" aoi = { "type": "Polygon", "coordinates": [[ [-122.4194, 37.7749], [-122.4094, 37.7749], [-122.4094, 37.7849], [-122.4194, 37.7849], [-122.4194, 37.7749] ]] } with requests.post( "https://api.vangrid.io/v1/spatial/stream", headers={"Authorization": f"Bearer {API_KEY}"}, json={"aoi": aoi, "min_ground_truth_score": 0.75}, stream=True ) as response: for line in response.iter_lines(): if line: event = json.loads(line) print(event) ``` ## Stream events Each line in the stream is a JSON object representing a single ground truth event: ```json theme={"dark"} { "event_id": "evt_8f3a2c1d", "timestamp": "2026-05-22T10:14:33.412Z", "geometry": { "type": "Point", "coordinates": [-122.4150, 37.7800] }, "observation_type": "vehicle", "ground_truth_score": 0.94, "node_count": 12, "provenance_hash": "sha256:a3f8e2c1b4d7f9e0a2b5c8d1e4f7a0b3c6d9e2f5" } ``` ### Event fields Unique identifier for this event. ISO 8601 UTC timestamp when the observation was captured. GeoJSON geometry of the observed feature. Classification of the observation. Confidence score (0.0–1.0) based on multi-node corroboration. Number of edge nodes that contributed to this observation. Cryptographic proof of data origin, verifiable via the provenance endpoint. ## Heartbeat events Every 30 seconds with no new observations, the server sends a heartbeat to keep the connection alive: ```json theme={"dark"} {"type": "heartbeat", "timestamp": "2026-05-22T10:15:03.000Z"} ``` Skip heartbeat events in your processing logic by checking `event.get("type") == "heartbeat"`. ## Connection limits and reconnection * Maximum one concurrent stream per API key by default * Streams time out after 24 hours; reconnect to resume * On disconnect, reconnect immediately, no data is buffered server-side during disconnection Data is not buffered if your client disconnects. Events that arrive while you are disconnected are not replayed. Design your system to tolerate gaps and rely on the spatial query endpoint to backfill if needed. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request higher concurrent stream limits or dedicated streaming infrastructure for production deployments. # Data pipeline Source: https://docs.vangrid.io/concepts/data-pipeline Capture, processing, signing, aggregation and delivery, step by step. The Vangrid data pipeline is the governed path that every observation travels from physical capture to your application. At each stage, the pipeline enforces sovereignty controls, preserves cryptographic integrity, and filters for quality, so what arrives in your API response is not just spatially accurate, but verifiably so. Understanding the pipeline helps you predict latency, interpret response fields, and design your system to take full advantage of Vangrid's guarantees. ## Pipeline stages Edge nodes capture spatial observations from their environment. Nodes operate independently and asynchronously, there is no central clock or coordinated capture event. Each node records the time and the location reported by the device at the moment of capture, and both travel with the observation for the rest of its life. The node runs detection on every frame as it is recorded and obscures faces and vehicle number plates before the video is encoded. Only the filtered capture is transmitted, and spatial features, object positions, geometries and classifications are extracted from it. Edge compute is the mechanism behind Vangrid's privacy guarantee: the unblurred frames never leave the hardware, so they cannot be intercepted, subpoenaed, or leaked in transit. No version of a capture in which a face or a number plate is legible exists anywhere off the device that recorded it. Running feature extraction on the node itself, so that only the derived payload is transmitted, will follow as device compute allows. After extracting features, the node signs the payload with its private key. The resulting `provenance_hash` encodes: * The node's unique identifier * The capture timestamp * A hash of the feature payload content The signature is generated on-device using hardware-backed key storage. Any modification to the payload after signing, in transit, at rest, or in your own systems, produces a hash mismatch that you can detect with standard cryptographic verification. Signed payloads from multiple nodes covering the same area of interest are ingested by Vangrid's aggregation layer. The aggregator: * Groups observations by spatial overlap and temporal proximity * Cross-corroborates observations from independent nodes to compute `ground_truth_score` * Detects and flags conflicting observations rather than silently resolving them * Merges compatible multi-view observations into unified feature records where appropriate Aggregation adds latency proportional to the number of nodes contributing to a response. Real-time queries use a shorter aggregation window; historical queries use a larger one. The aggregated, scored response is returned to your application as structured JSON over HTTPS. The response body contains a `features` array, each element carrying geometry, timestamps, quality scores, provenance, and any domain-specific fields relevant to your query type. ## What "sovereign" means In the context of the Vangrid pipeline, **sovereign** means that data does not transit infrastructure outside your designated boundary without explicit, auditable consent. Sovereignty operates at three levels: * **Node-level**, Identifiable frames stay on the node. Faces and number plates are obscured before anything is transmitted, so they never traverse a network at all. * **Infrastructure-level**, Signed feature payloads are routed only through Vangrid infrastructure within your configured sovereignty boundary. No third-party cloud provider or transit network touches your data without your authorization. * **API-level**, Your API responses are delivered over TLS. Vangrid does not log or store query content beyond what is required for billing and provenance records. For defense and government deployments, Vangrid supports nation-state grade sovereignty controls including air-gapped delivery modes, region-locked infrastructure, and custom key management integration. Contact [hello@vangrid.io](mailto:hello@vangrid.io) for details on these configurations. Standard enterprise accounts operate within a single-region sovereignty boundary by default. Cross-region access requires explicit configuration and is audited in your account's provenance log. ## Latency characteristics Real-time queries return observations captured within the last few seconds to minutes, depending on node density and AOI size. The aggregation window is short, Vangrid does not wait for all possible contributing nodes before returning a response. You receive a partial but fast result, with `node_count` and `ground_truth_score` reflecting the nodes that responded within the window. Typical p50 latency for a real-time query over a small urban AOI is under 500ms from request to first byte. Larger AOIs or lower-density regions will be slower. Historical queries retrieve observations from Vangrid's provenance archive. Because the data is already aggregated and stored, historical queries are not subject to node response latency, but they do incur retrieval and decryption overhead. Historical responses include the full set of contributing nodes and their individual signed payloads, giving you a richer audit trail than real-time queries. Typical latency for historical queries is 1–5 seconds depending on archive depth and result size. For applications that need continuous updates, fleet tracking, infrastructure monitoring, real-time situational awareness, Vangrid supports streaming subscriptions via WebSocket. Observations matching your AOI and filter criteria are pushed to your connection as they are aggregated, with latency comparable to real-time queries. ## Response data format Every Vangrid API response is a GeoJSON-compatible JSON object. The top-level structure includes a `features` array where each element represents one spatial observation. ```json theme={"dark"} { "query_id": "qry_01j9z3kfm8x2v4n7", "timestamp": "2026-05-22T14:32:07.412Z", "aoi": { "type": "Polygon", "coordinates": [[[-122.4194, 37.7749], [-122.4094, 37.7749], [-122.4094, 37.7849], [-122.4194, 37.7849], [-122.4194, 37.7749]]] }, "node_count": 14, "features": [ { "feature_id": "feat_7d3a9c2e", "type": "Feature", "geometry": { "type": "Point", "coordinates": [-122.4142, 37.7799, 12.4] }, "properties": { "classification": "vehicle.truck", "velocity_mps": 4.2, "heading_deg": 273.1, "captured_at": "2026-05-22T14:32:05.198Z", "ground_truth_score": 0.94, "provenance_hash": "sha256:a3f8c1d9e4b27056f3a8c9d1e4b270a3f8c1d9e4b27056f3a8c9d1e4b270", "sensor_modalities": ["camera", "lidar"], "node_count": 3 } } ] } ``` Key response fields: | Field | Type | Description | | - | - | - | | `query_id` | string | Unique identifier for this query, used in audit logs and support. | | `node_count` | integer | Total number of nodes that contributed to this response. | | `feature_id` | string | Unique identifier for this observation. | | `geometry` | GeoJSON geometry | Position and shape of the observed feature. Coordinates are `[longitude, latitude, altitude_meters]`. | | `classification` | string | Hierarchical object classification (e.g., `vehicle.truck`, `person.pedestrian`). | | `captured_at` | ISO 8601 string | Timestamp of the original sensor capture on the node. | | `ground_truth_score` | float | Confidence score from 0.0 to 1.0 based on multi-node corroboration. | | `provenance_hash` | string | Cryptographic signature of this observation. | | `sensor_modalities` | array | Sensor types that contributed to this feature. | ## How Vangrid differs from cloud-only alternatives Cloud-only spatial platforms funnel unfiltered footage into a central processing cluster before returning results. This design introduces several limitations that Vangrid's pipeline avoids: | | Cloud-only platforms | Vangrid | | - | - | - | | **Privacy** | Identifiable footage transits and is stored in the cloud | Unblurred frames never leave the device | | **Provenance** | No per-observation cryptographic proof | Every feature carries a `provenance_hash` | | **Sovereignty** | Data crosses arbitrary cloud regions | Data stays within your configured boundary | | **Latency** | Round-trip to central cluster | Aggregation happens close to the edge | | **Infrastructure cost** | You pay for cloud compute and storage | Vangrid absorbs node and compute costs | When comparing Vangrid to a cloud-only alternative, ask the vendor: "Can you prove that a specific observation was not altered between capture and delivery?" With Vangrid, the `provenance_hash` answers that question without requiring you to trust any intermediary. # Edge nodes Source: https://docs.vangrid.io/concepts/edge-nodes An edge node is a phone running the Vangrid capture app. How the network is structured. An edge node is a person's phone running the Vangrid capture app. That is the whole of it. There is no hardware to ship, no fleet to maintain, and no installation. A contributor opens the app, records a capture of a place, and the device signs and submits it. The network is built to run on the phones people already carry, which is the only sensor deployment that reaches street level everywhere at once. Coverage therefore follows people rather than infrastructure. It is densest where contributors are active and thin where they are not, and it grows through [bounties](/contribute/bounties): a request for a specific place, funded, that contributors compete to fulfil. ## No hardware to deploy Traditional spatial data workflows require you to procure sensors, manage deployments, handle maintenance, and build ingestion pipelines. Vangrid removes that layer. You access captured data through the API, and commission new captures through bounties. When you make a spatial query, Vangrid identifies which nodes cover your area of interest, routes your request to them, aggregates their responses, and returns a single verified payload. From your perspective, the network behaves like a continuously operating sensor grid that you query on demand. You are billed for the data you retrieve and for the bounties you fund. There is no hardware cost to pass on. There is no capital expenditure on sensors, because the sensors are phones that already exist. You pay for the data you retrieve. ## Node density and coverage Vangrid's network is designed for **tactical urban density**, the highest node concentrations are in metropolitan areas where autonomous systems, logistics, and infrastructure monitoring have the greatest need for fine-grained, continuous spatial data. In dense urban environments, multiple nodes typically cover any given location simultaneously, often from different vantage points and elevations. This overlap is intentional: it enables multi-view corroboration, which is the mechanism Vangrid uses to calculate the `ground_truth_score` for each observation. Coverage density varies by region. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to confirm node coverage for a specific AOI before building production workflows that depend on it. Outside major urban centres, coverage is sparser. Where a place is not covered, post a bounty for it. ## Multi-view ingestion Captures of the same place come from different people, at different times, from different positions and heights. When you query an area of interest, the observations returned are drawn from those independent captures. Multi-view ingestion means the Vangrid aggregation layer combines observations from nodes with different physical perspectives and sensor types. This produces several advantages: * **Occlusion handling**, An object hidden from one node's line of sight is often visible to another. * **Independent corroboration**, Agreement between captures recorded by different contributors at different times increases confidence in the result. * **Redundancy**, If one capture is low quality, other captures of the same place continue contributing. The `sensor_modalities` array in each API response lists the sensor types that contributed to that observation, so you can filter or weight results based on the modalities your application depends on. ## How nodes are selected for your query When you submit a spatial query, you specify an area of interest (AOI) as a GeoJSON polygon or bounding box along with a time range. Vangrid's routing layer identifies all active nodes whose coverage intersects the AOI during the requested time window. Node selection factors include: * **Geographic overlap**, The node's coverage area must intersect your AOI. * **Temporal availability**, The node must have been active and capturing during your requested time range. * **Data quality**, Nodes with persistent quality issues or flagged hardware are deprioritized. * **Sovereignty boundary**, Only nodes within your configured data boundary are eligible. Smaller AOIs return faster responses with higher node density per unit area. If you need broad coverage, consider issuing multiple targeted queries rather than a single large-polygon query. ## Edge-computed privacy Every node processes raw sensor data locally before transmitting anything to the network. Raw frames, point clouds, and sensor streams never leave the device. What the node transmits is a structured feature payload, spatial geometry, object classifications, timestamps, and metadata, derived from the raw data but containing no recoverable raw content. This means: * Personally identifiable information (faces, license plates, biometrics) is never present in API responses. * Sensitive scene details are not stored or transmitted by the infrastructure. * Privacy compliance is enforced at the hardware boundary, not in a downstream filtering layer that could be misconfigured or bypassed. Edge-computed privacy is a network-level guarantee, not a configurable option. It applies to all nodes in the Vangrid network regardless of deployment region or query type. # Ground truth Source: https://docs.vangrid.io/concepts/ground-truth Verified real world observations with a provenance record, and how confidence is scored. The API is in early access and is not publicly available. Endpoint URLs, request examples and sample responses on this page are illustrative. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request access. In Vangrid, ground truth is not a marketing term, it is a precisely defined data quality guarantee. Every observation labeled as ground truth was captured by physical sensors in the real world, corroborated by multiple independent nodes, and signed with a cryptographic hash that proves it hasn't been altered. This distinguishes Vangrid's output from inferred, modeled, or synthetic spatial data, which may be statistically plausible but cannot be independently verified. ## What ground truth means in Vangrid's context A ground truth observation in Vangrid meets three criteria: 1. **Physical capture**, The observation originates from a real sensor in the real world at a specific location and time. No portion of the observation is generated by a model or interpolated from adjacent data. 2. **Multi-node corroboration**, At least one additional independent node has captured a consistent observation of the same feature within the same spatiotemporal window. Single-node observations are returned with a low `ground_truth_score` and clearly marked as unconfirmed. 3. **Cryptographic provenance**, The observation carries a `provenance_hash` generated on the originating node. The hash ties the observation to a specific device, timestamp, and content, giving you tamper-evident proof of its origin. If any of these three criteria are not met, the observation is returned with a lower score or flagged in the response. Vangrid does not suppress low-confidence observations, it surfaces them with the metadata you need to decide whether to use them. ## How `ground_truth_score` is calculated The `ground_truth_score` is a confidence metric between `0.0` and `1.0` that reflects the degree of multi-node corroboration for a given observation. The score increases as: * More independent nodes report consistent observations of the same feature * The contributing nodes use different sensor modalities (cross-modal agreement is weighted more heavily than same-sensor agreement) * The temporal spread between contributing observations is smaller (nodes that agree within milliseconds provide stronger corroboration than nodes that agree across minutes) The score decreases when: * Only one node contributed to the observation * Contributing nodes disagree on position, classification, or velocity beyond the configured tolerance thresholds * One or more contributing nodes have a degraded hardware quality rating A `ground_truth_score` of `1.0` does not mean certainty, it means the maximum corroboration achievable given the nodes that responded to your query. Always consider `node_count` alongside the score: a `1.0` from two nodes in a sparse area carries less weight than a `0.92` from fourteen nodes in a dense urban deployment. The score is not a probability estimate, it is a normalized measure of corroboration strength. How you threshold it depends on your application's tolerance for uncertainty. Common patterns: | Use case | Recommended minimum `ground_truth_score` | | - | - | | Archival or audit records | `0.5`, include with metadata for human review | | Autonomous system inputs | `0.85`, high corroboration required for safety-critical decisions | | Real-time situational awareness | `0.7`, balance between coverage and confidence | | Historical analysis | `0.6`, broader inclusion for statistical work | ## Ground truth vs. inferred and synthetic data It is important to understand what Vangrid's ground truth is not. **Inferred data** is produced by a model that estimates the state of a scene based on partial observations or prior patterns. For example, a system that predicts vehicle positions between sensor captures using a motion model is producing inferred data, not ground truth. Inferred data can be highly accurate, but it cannot be verified against a physical observation. **Synthetic data** is generated entirely by simulation or generative models. It is useful for training and testing, but it describes a virtual world, not the physical one. Vangrid does not mix inferred or synthetic observations into its ground truth responses. Every feature in a Vangrid API response either originated from a physical sensor or is explicitly flagged with a `data_source` value of `interpolated` (for gap-filled historical records) or `estimated` (for low-confidence single-node observations pending corroboration). If you need synthetic or inferred data, for simulation environments, training datasets, or counterfactual analysis, Vangrid does not provide it. Vangrid's value proposition is physical ground truth, not modeled approximations. ## How cryptographic provenance proves authenticity Every observation in a Vangrid response includes a `provenance_hash` field. This hash is generated on the originating edge node using the node's hardware-backed private key. It encodes: * The node's unique identifier * The time and location the device recorded at the moment of capture * A SHA-256 hash of the observation's feature payload To verify a `provenance_hash`, you submit it to the Vangrid Provenance API along with the feature payload. The API checks the signature against the node's public key and returns a verification result. If the payload was modified at any point after capture, in transit, in Vangrid's infrastructure, or in your own systems, the verification will fail. For defense, compliance, or auditing workflows, archive the `provenance_hash` alongside your application data at ingest time. You can verify the chain of custody months or years later without depending on Vangrid retaining the original observation. ## Real-time vs. historical ground truth Vangrid supports two query modes, and the choice affects how you should interpret `ground_truth_score` and `provenance_hash`. Real-time queries return observations captured within a short rolling window (typically the last few seconds to minutes). Because the aggregation window is short, some nodes may not have contributed yet when your response is assembled. This means: * `node_count` may be lower than what a historical query for the same time and place would show * `ground_truth_score` may be lower than it will be once all nodes have reported * The response is assembled quickly, but it reflects the network state at query time, not the fully-corroborated state Use real-time ground truth when your application requires low latency, autonomous navigation, real-time fleet tracking, live situational awareness. Historical queries retrieve observations from Vangrid's provenance archive, where corroboration has had time to complete. For any given point in time, a historical query will typically return higher `ground_truth_score` values and higher `node_count` values than a real-time query for the same moment would have returned. Historical responses also include the full set of contributing node identifiers and their individual signed payloads, useful for audits or forensic reconstruction of a scene. Use historical ground truth for compliance records, incident investigation, training data generation, and any workflow where completeness matters more than latency. ## Example API response with ground truth fields The following shows a single feature from a real-time spatial query. Note the `ground_truth_score`, `provenance_hash`, and supporting fields that together constitute a verified ground truth observation. ```json theme={"dark"} { "feature_id": "feat_9b1e3c7d", "type": "Feature", "geometry": { "type": "Point", "coordinates": [-73.9857, 40.7484, 8.1] }, "properties": { "classification": "person.pedestrian", "velocity_mps": 1.3, "heading_deg": 45.0, "captured_at": "2026-05-22T14:32:05.198Z", "ground_truth_score": 0.91, "provenance_hash": "sha256:c7f2a49d1e8b3056a7f2c49d1e8b3056c7f2a49d1e8b3056a7f2c49d1e8b30", "node_count": 4, "sensor_modalities": ["camera", "depth"], "data_source": "ground_truth", "corroboration_window_ms": 312 } } ``` Key fields in this response: | Field | Value | What it tells you | | - | - | - | | `ground_truth_score` | `0.91` | High corroboration, 4 independent nodes agreed within 312ms. | | `provenance_hash` | `sha256:c7f2...` | Cryptographic proof of origin. Submit to the Provenance API to verify. | | `node_count` | `4` | Four independent nodes contributed to this observation. | | `sensor_modalities` | `["camera", "depth"]` | Both camera and depth sensors agreed, cross-modal corroboration. | | `data_source` | `ground_truth` | This is a physical observation, not interpolated or estimated. | | `corroboration_window_ms` | `312` | All four nodes reported within 312 milliseconds of each other. | # How Vangrid works Source: https://docs.vangrid.io/concepts/overview How captures move from a phone to a verified observation delivered through the API. Vangrid is a decentralized data rail, a continuously growing network of edge nodes that captures real-world spatial observations, filters them for privacy on the device that recorded them, and delivers verified results to your application through a single REST API. Understanding how data moves through this pipeline helps you write better queries, interpret responses correctly, and design systems that rely on ground truth rather than approximations. ## Key terminology Before walking through the pipeline, it helps to understand the core terms you'll encounter throughout these docs. Ground truth refers to verified, real-world spatial observations captured directly by physical sensors. In Vangrid's context, ground truth data is corroborated by multiple independent edge nodes and accompanied by a cryptographic provenance hash that proves its origin and integrity. Ground truth is distinct from inferred or synthetic data, it reflects what actually existed in the physical world at a specific place and time. An edge node is a phone running the Vangrid capture app. Nodes capture multi-view video of a place, and faces and vehicle number plates are obscured on the device before the video is encoded. You never purchase or manage edge nodes: you query the network, and Vangrid routes your request to the nodes that cover your area. A provenance hash is a cryptographic signature attached to every Vangrid data response. It encodes the identity of the originating node, the capture timestamp, and a hash of the raw observation, giving you tamper-evident proof that the data hasn't been altered between capture and delivery. You can use the hash to audit, archive, or independently verify any response. A spatial query is an API request that specifies a geographic area of interest (AOI), a time range, and optional filters. Vangrid routes the query to edge nodes that cover the AOI, aggregates their responses, and returns a ranked, provenance-stamped payload. Queries can return real-time observations or historical records. The data rail is Vangrid's end-to-end pipeline, from edge capture through edge-compute, cryptographic signing, aggregation, and API delivery. Calling it a "rail" emphasizes that data moves along a defined, governed path with sovereignty controls at each stage, rather than being routed through arbitrary third-party infrastructure. ## How data flows through Vangrid The pipeline moves data from the physical world to your application in five stages. Edge nodes capture spatial observations from their environment. Each node operates independently, and nodes in the same area observe the same scene from different positions and at different times, producing multi-view coverage that no single pass can. The ingestion path is sensor agnostic by design: as phones ship with depth and lidar sensors, those modalities will flow through it without a change to the query interface. The node runs detection on every frame as it is recorded and obscures faces and vehicle number plates before the video is encoded. The unblurred frames never leave the device: they are not uploaded, not stored, and not recoverable later. Privacy is enforced at the moment of capture rather than by policy after the fact. Extracting spatial features on the node itself, so that only the derived payload is transmitted, will follow as device compute allows. After local processing, each node signs its observation with a private key. The resulting provenance hash encodes the node identity, capture timestamp, and observation content. Any downstream modification to the data would invalidate the signature, giving you a verifiable chain of custody from sensor to API response. Signed observations from multiple nodes covering the same AOI are aggregated by Vangrid's infrastructure. Observations are cross-corroborated to produce a `ground_truth_score`, a confidence metric that increases as more independent nodes agree on the same spatial state. Conflicting observations are flagged rather than silently discarded. The aggregated, scored, and signed payload is returned through the Enterprise Spatial API as structured JSON. Each feature in the response includes geometry, timestamps, `ground_truth_score`, and `provenance_hash`. You can use the response directly, stream it to downstream systems, or archive it with the provenance hash for future audits. Vangrid routes every query through nodes within your designated data sovereignty boundary. Data does not transit infrastructure outside that boundary unless you explicitly configure cross-region access. ## What makes this different from cloud-first alternatives Most spatial data platforms send whatever the sensor saw to a central cloud and filter it there, if at all. Two problems follow: identifiable footage exists in someone else's infrastructure, and there is no per-observation provenance to audit. Vangrid inverts this model. Filtering happens on the device, so no version of a capture in which a face or a number plate is legible exists anywhere off that device. Provenance is attached at the source, and the API layer is a thin delivery surface over the network. You get stronger privacy guarantees and a verifiable record for every observation, without deploying any infrastructure. If you are building a system that needs to demonstrate data integrity to regulators, auditors, or partners, store the `provenance_hash` from each response alongside your application data. You can use it to reconstruct and verify the chain of custody at any time. ## Explore the pipeline in depth How the node network is structured, how nodes are selected for your queries, and what multi-view ingestion means in practice. A step-by-step breakdown of how data moves from capture through signing to your API response, including latency and format details. How Vangrid defines and calculates ground truth, what the `ground_truth_score` means, and when to use real-time vs. historical data. # Bounties Source: https://docs.vangrid.io/contribute/bounties A funded request for a capture of something specific. How to post one, how to submit, and how the reward is paid. A bounty is a funded request for a capture of something specific. A building, a junction, a warehouse floor, a stretch of road. Anyone can submit to it. The requester picks one submission, and that contributor gets paid. This is how data moves on Vangrid today: by commission. A catalogue of already captured data will follow as coverage grows. Bounties live at [data.vangrid.io](https://data.vangrid.io). Software can post them too: an AI agent pays the bounty in USDC on Base or Arc through one HTTP call and receives the reconstruction the same way, see [Bounties for agents](/api/agent-bounties). ## Post a bounty Give it a title and describe exactly what to capture and where. Precision here decides the quality of what you get back. You pay once, for example \$50, and you choose how long the bounty stays open. Reconstruction of the winning capture is included, so there is no second payment. The reward is escrowed in USDC on Base before anyone starts working, so contributors can see the money is there. It stays locked until you accept a submission. Submissions arrive against your brief. Accepting one releases the reward. Cancel any time before you accept and the full amount comes back to you. If the deadline passes without an accepted submission, the bounty closes and the reward is returned the same way. ## Submit to a bounty Record a new one, or use a clip you have already captured. Both work. Send your clip with a short note for the requester. You pay nothing to submit. Reconstruction is covered by the bounty. Many contributors can submit to the same bounty. A bounty can only be accepted while it is still open, so submit before the deadline. If your submission is accepted, Vangrid pays you the reward. If it is not, the clip stays yours. ## What happens after accept Accepting closes the bounty on chain and releases the escrow. The winning capture goes into reconstruction, and the requester receives a textured mesh in GLB format. Reconstruction typically takes 30 minutes or more. Per stage progress inside your account, with a live status for each reconstruction, will follow. ## Where the money goes The reward is escrowed when the bounty is funded and released when you accept it. Vangrid takes the platform fee, currently 10%, covers the cost of reconstruction, currently around \$5, and pays the rest to the contributor. With current defaults, a \$50 reward pays \$5 to the platform, \$5 for reconstruction, and \$40 to the contributor. These figures are examples and can change. ## Privacy The escrow and the settlement are written on chain. That is deliberate: it is what lets a contributor confirm the money exists before spending an afternoon capturing, and what lets a requester prove a deal happened without taking anyone's word for it. What stays private is the substance. Only a hash of the delivered dataset goes on chain, never the footage, never the brief, and never the identity of the contributor who fulfilled it. Requesters never receive raw video. They receive the reconstructed 3D model. The original footage stays with the contributor. # Capture and privacy Source: https://docs.vangrid.io/contribute/capture How to record a capture, what happens to faces and number plates, and where uploads are unavailable. ## Recording a capture Open [app.vangrid.io](https://app.vangrid.io), choose **Capture Data**, and allow camera access. Allow location if you want the capture to appear on the map. The capture app runs in any browser. On Android it is also on [Google Play](https://play.google.com/store/apps/details?id=io.vangrid.app), and it is the same app either way. Record while walking slowly around the subject. Keep the phone steady, cover every side you can reach, and do not pan quickly. A capture that misses a side produces a 3D model with a hole in it. When you stop recording, the clip uploads and goes through an automatic quality check. Clips that are too short or unreadable are rejected, and you are told why. A clip that passes is ready to submit to a bounty at [data.vangrid.io](https://data.vangrid.io). ## What happens to faces and number plates Faces and vehicle number plates are detected and blurred on your phone, while you record. The blur is applied before the video is encoded. The unblurred frames never leave your device. Only the blurred video is uploaded. ## Location If you allow location, your capture is geotagged and appears on the map. Captures without location still work. They do not appear on the map, and some bounties require location to verify that you captured the right place. ## Where uploads are unavailable Uploads are not available in every region. If yours is restricted you will see "Uploads are not available in your region." This is based on the location of the capture and on your network region. ## If you appear in a capture Anyone who appears in a capture can request removal or additional blurring. Write to [privacy@vangrid.io](mailto:privacy@vangrid.io). The [Privacy Policy](/legal/privacy-policy) sets out the process and the timescales. # Points and wallet Source: https://docs.vangrid.io/contribute/points-and-wallet Points measure contribution and rank. Bounty rewards are money and are paid separately. ## Points Vangrid posts its own bounties for places it wants covered. They work like any other bounty, with one difference: the reward is points rather than money. Points are awarded after a capture has been processed successfully, not when you upload it. Points measure your contribution to the network and your rank within it. ## Wallet Your wallet is your sign in. It shows your points, your rank, and the bounty rewards recorded against your address. ## Bounty rewards Bounty rewards are money and are separate from points. When a requester accepts your submission, Vangrid pays out the reward. # Cryptographic provenance Source: https://docs.vangrid.io/data/cryptographic-provenance Every observation carries a provenance hash. How to verify one independently. The API is in early access and is not publicly available. Endpoint URLs, request examples and sample responses on this page are illustrative. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request access. Every observation returned by the Vangrid API includes a `provenance_hash`, a SHA-256 digest that lets you verify, independently, that the data came from a legitimate Vangrid edge node, at the stated time, and has not been modified in transit or storage. This is critical for defense, compliance, and safety applications where data integrity is non-negotiable. ## What the provenance hash covers The `provenance_hash` is computed over: * The observation payload (geometry, classification, scores) * The originating node's unique identifier * The capture timestamp (UTC, millisecond precision) * The Vangrid network epoch (a rotating network-wide nonce) Any change to any of these inputs produces a completely different hash. If a hash you received matches the hash you compute from the payload, the data is authentic. ## Verifying a provenance hash Make a spatial query or read from a streaming event. Note the `provenance_hash` field. Call `GET /v1/provenance/{provenance_hash}` with your API key to retrieve the signed verification record. The response includes the canonical hash computed by the issuing node. Compare it to the hash in your observation. ```python Python theme={"dark"} import requests API_KEY = "your-api-key" BASE_URL = "https://api.vangrid.io/v1" def verify_provenance(provenance_hash: str) -> bool: response = requests.get( f"{BASE_URL}/provenance/{provenance_hash}", headers={"Authorization": f"Bearer {API_KEY}"} ) if response.status_code == 200: record = response.json() return record["verified"] is True return False # Example usage is_valid = verify_provenance("sha256:a3f8e2c1b4d7f9e0a2b5c8d1e4f7a0b3c6d9e2f5") print(f"Provenance valid: {is_valid}") ``` ## Verification response ```json theme={"dark"} { "provenance_hash": "sha256:a3f8e2c1b4d7f9e0a2b5c8d1e4f7a0b3c6d9e2f5", "verified": true, "node_id": "node_7f3a", "captured_at": "2026-05-22T10:14:33.412Z", "network_epoch": "epoch_2026_05", "signature_algorithm": "ECDSA-P256" } ``` A `verified: false` result means the hash could not be matched in the Vangrid ledger. Do not use this observation for safety-critical decisions. Archive provenance hashes alongside your observations in your own storage. You can re-verify them at any time using the verification endpoint. # Data sovereignty Source: https://docs.vangrid.io/data/data-sovereignty Residency, region scoped keys and access boundaries for enterprise deployments. The API is in early access and is not publicly available. Endpoint URLs, request examples and sample responses on this page are illustrative. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request access. Data sovereignty means that the spatial intelligence you receive through Vangrid stays within the jurisdictional and organizational boundaries you define. Vangrid is designed from the ground up to support nation-state grade sovereignty requirements, not as an add-on, but as a core architectural property. ## What data sovereignty means in Vangrid Sovereignty in Vangrid operates at three levels: **Node level**, Faces and vehicle number plates are obscured on the device before anything is transmitted, so identifiable frames never cross a jurisdictional boundary. **Network level**, Your API key can be scoped to specific geographic regions. Queries outside your authorized regions are rejected, not silently filtered. **API level**, All data returned to your application is tagged with the originating region and epoch. You can audit exactly what entered your systems and from where. ## Geographic access controls When you onboard, Vangrid configures your API key with one or more authorized regions. A region is a named geographic boundary (e.g., a country, a state, or a custom polygon). ```bash theme={"dark"} # Query is scoped to your authorized region automatically curl -X POST https://api.vangrid.io/v1/spatial/query \ -H "Authorization: Bearer your-api-key" \ -H "Content-Type: application/json" \ -d '{ "aoi": { "type": "Polygon", "coordinates": [[[...coordinates...]]] } }' ``` If your AOI extends outside your authorized region, the API returns a `403 Forbidden` with: ```json theme={"dark"} { "error": "region_not_authorized", "message": "Your AOI intersects regions not authorized for this API key.", "unauthorized_regions": ["region_us_ca_north"] } ``` ## Data residency For enterprise and defense customers, Vangrid offers dedicated data rail configurations where: * Processing and aggregation occur within a specific country or jurisdiction * No query metadata or results are replicated outside the authorized region * Cryptographic provenance records are stored within the same jurisdictional boundary Data residency configurations require a custom enterprise agreement. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to discuss your requirements. ## Compliance considerations Vangrid's architecture is designed to support compliance frameworks that require: * Data not leaving a defined geographic perimeter * Audit trails for all data access (available via your account dashboard) * Cryptographic proof that data has not been tampered with in transit If you operate under specific regulatory requirements (e.g., ITAR, national data protection laws), share those requirements when you contact Vangrid. Sovereign deployment configurations are available for qualifying customers. # Privacy at capture Source: https://docs.vangrid.io/data/edge-privacy Faces and number plates are blurred on the device before the video is encoded. Unblurred frames never leave the phone. Vangrid's privacy model is architectural rather than a policy statement. The filtering happens on the contributor's device, at the moment of recording, before anything is transmitted. ## What happens on the device While a contributor records, the app detects faces and vehicle number plates in each frame and obscures them. The obscured frames are what get encoded into the video file. The consequence is the part that matters: **the unblurred frames never leave the device.** They are not uploaded, not stored, and not recoverable later. Vangrid never holds a version of the capture in which a face or a number plate is legible. No automated detector is perfect. Contributors remain responsible for not recording what should not be recorded, and anyone who appears in a capture can ask for removal or further obscuring. See [Privacy Policy](/legal/privacy-policy). ## What Vangrid holds The blurred video is uploaded and reconstructed into a 3D model. Vangrid holds both: the blurred capture and the model derived from it. Contributors keep control of their own footage. It is never handed to a buyer. ## What a buyer receives | | Delivered to buyers | Not delivered | | - | - | - | | Reconstructed 3D model | Yes | | | Geometry, classification, ground truth score | Yes | | | Provenance record | Yes | | | The contributor's video | | Never | | Unblurred frames | | Do not exist off the device | A buyer reviewing a bounty submission sees enough to judge it against their brief. On acceptance they receive the reconstructed model. At no point do they receive the source video. ## Privacy zones Contributors can designate personal privacy zones, such as a home or a workplace, where capture is disabled. Network level privacy zones around sensitive locations are enforced on the server, and uploads inside them are rejected. ## Where uploads are unavailable Uploads are blocked in some regions for legal reasons, based on the location of the capture and the contributor's network region. ## Your queries Query parameters are not retained beyond the request lifecycle. Results are scoped to the regions your API key is authorised for, and query history is not shared between customers. If your use case requires data residency guarantees, see [Data sovereignty](/data/data-sovereignty) or write to [hello@vangrid.io](mailto:hello@vangrid.io). # Enterprise API overview Source: https://docs.vangrid.io/enterprise/api Spatial query, ingestion, streaming and provenance verification. Access is granted per pilot. The Vangrid Enterprise Spatial API gives programmatic access to verified spatial observations: query an area, ingest your own observations, subscribe to a live feed, and verify provenance independently. Access is granted per pilot. Credentials are issued on onboarding and scoped to the regions your account is authorised for. The API is in early access and is not publicly available. Endpoint URLs, request examples and sample responses across the API reference are illustrative. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request access. ## What the API covers | Operation | Purpose | | - | - | | [Spatial query](/api/spatial-queries) | Return verified observations for an area of interest and a time window | | [Data ingestion](/api/data-ingestion) | Submit your own observations into the network and receive a provenance record | | [Streaming](/api/streaming) | Subscribe to a push feed of observations for a defined area | | [Provenance verification](/data/cryptographic-provenance) | Confirm independently that an observation is authentic and unaltered | ## Authentication and regions Access uses bearer API keys. Keys are scoped to a region and rate limited per account. A key scoped to one region does not return observations from another; a request that crosses the boundary is rejected rather than silently filtered. Regions are `us-east-1`, `eu-west-1` and `apac-1`. Dedicated residency configurations are available under an enterprise agreement. ## Provenance verification is the one that matters Of the four operations, provenance verification is the one to read first. It answers a question no vendor can answer about itself: whether a given observation is authentic. It is designed to be answerable by a customer holding the observation and its hash, without trusting any other Vangrid response. # For enterprise Source: https://docs.vangrid.io/enterprise/overview Ground level spatial data with verifiable provenance, and commissioned capture through bounties. Vangrid delivers ground level spatial data with verifiable provenance, and commissioned capture of specific locations through bounties. It is built for teams training and operating physical systems: robotics, autonomous platforms, simulation, and mapping. ## What you get Reconstructed 3D models of real places, each traceable to the capture it came from, and each capture carrying a cryptographic fingerprint taken at the moment of recording. Output is a textured mesh in GLB format. ## Where to start Open [app.vangrid.io](https://app.vangrid.io) and choose **Buy Data**, or go straight to [data.vangrid.io](https://data.vangrid.io). ## Commissioned capture If the place you need is not covered, post a bounty. You describe the location and what matters in it, fund a reward, review submissions, and accept the one you want. Reconstruction is included. ## Data residency Data can be routed within a region. Available regions are `us-east-1`, `eu-west-1` and `apac-1`. Access across regions requires explicit configuration on the account. ## Access Access is early and granted per pilot. Email [hello@vangrid.io](mailto:hello@vangrid.io) with a short description of your use case and the regions you need. # FAQ Source: https://docs.vangrid.io/faq Sign in, invite codes, reconstruction time, refunds, rewards and points. Connect your wallet. There is no email and no password. To upload captures. Browsing bounties does not need one. No. Reconstruction is covered by the bounty. 30 minutes or more. No. They receive the finished 3D model. The original footage stays with you. Yes, any time before you accept a submission. If the deadline passes and you have accepted nothing, the reward is returned to you the same way. If your submission is accepted, Vangrid pays out the reward. They measure your contribution and your rank. # Vangrid Source: https://docs.vangrid.io/index The spatial data layer for physical AI. Ground level, verifiable, captured by people. Physical AI needs to know what the world actually looks like from the ground. Satellites see roofs. Mapping fleets see roads they can drive. Neither sees a stairwell, a loading bay, a market street, or the inside of a warehouse. Vangrid collects that view. Contributors record short videos with an ordinary phone. Those videos are reconstructed into 3D models. Organisations that need something specific captured post a bounty, fund it, and contributors go and capture it. Every capture is fingerprinted at the moment it is recorded: a hash of the content, a coarse location, a timestamp. Fingerprints are batched and their root is anchored on Base, which turns each one into something a buyer can check against a public ledger rather than against our word, and that is what makes crowd captured data usable for training and for procurement. **Agents can now hire humans to capture the physical world.** An AI agent posts a bounty with one HTTP call, pays it in USDC on Base or Arc through x402, a person goes and films the place, and the reconstruction comes back through the same API. No account, no API key. [Bounties for agents](/api/agent-bounties) ## Three roles Record captures and fulfil bounties. Post and fund bounties, review submissions, accept one. Commission captures and buy anchored data from software, paid per call in USDC on Base or Arc. ## Where to start Everything begins at [app.vangrid.io](https://app.vangrid.io), which has two doors: **Capture Data** for contributors, which opens the capture app at [app.vangrid.io/capture](https://app.vangrid.io/capture), and **Buy Data** for organisations, which opens [data.vangrid.io](https://data.vangrid.io). Connect a wallet, record your first capture, submit it to a bounty. Browser or Android. Commission a capture of a specific place. What proves a capture is real. Data access, residency, and the spatial API. Commission a capture or query anchored data with one paid call. # Privacy Policy Source: https://docs.vangrid.io/legal/privacy-policy Vangrid Privacy Policy — last updated May 22, 2026. **Last Updated: May 22, 2026** ## 1. Data Controller Aurevion Group Ltd., a BVI business company (company number 2208282) with its registered office at Intershore Chambers, 3rd Floor, Geneva Place, P.O. Box 4342, Road Town, Tortola, British Virgin Islands, trading as Vangrid, is the data controller for personal information processed through the Service. Contact: [privacy@vangrid.io](mailto:privacy@vangrid.io). ## 2. Privacy-by-Design Architecture Vangrid is engineered so that personally identifiable information never leaves the contributor's device: * Face detection and obfuscation runs on-device using ML inference before any encoding * License plate detection and obfuscation runs on-device * Body silhouette pixelation applies before frame encoding * Vangrid servers receive only post-filter spatial geometry and metadata * Unblurred imagery is never transmitted, accessed, or stored by Vangrid We process spatial geometry of public infrastructure, not surveillance data of people. ## 3. Data We Collect **Wallet address** — Ethereum wallet, used as pseudonymous account identifier. Legal basis: contract (GDPR Art. 6(1)(b)). **Filtered spatial captures** — post-blur video and derived geometry. Legal basis: legitimate interest (GDPR Art. 6(1)(f)). **GPS coordinates** — attached to each scan for spatial indexing and fraud prevention. Legal basis: legitimate interest. **Device metadata** — timestamps, capture duration, technical telemetry. Legal basis: legitimate interest. **Discord ID** — collected only if user voluntarily links account for access code delivery. Legal basis: consent (GDPR Art. 6(1)(a)). We do **NOT** collect: name, email (unless you contact us), phone number, biometric templates, government IDs, payment information, or precise home addresses. ## 4. Privacy Zones & Contributor Controls Contributors may designate personal privacy zones (home, workplace) where capture is automatically disabled. Network-level privacy zones around sensitive areas are enforced server-side and reject uploads within them. ## 5. Purpose of Processing We process data to operate the decentralized perception grid, train spatial models, and provide derived geometric data to enterprise customers building autonomous systems and defense applications. We balance this legitimate interest against contributor and bystander privacy through our edge-filter architecture. ## 6. Data Sharing We do **NOT** sell personal data. Filtered spatial datasets (containing no PII) may be licensed to: * Defense and government customers under strict use restrictions * Robotics and autonomous-systems developers * World-model and AI research labs * Critical infrastructure operators Service providers acting on our behalf (cloud hosting, analytics) are bound by data processing agreements. ## 7. International Transfers Personal data may be transferred outside the EEA/UK/Switzerland. Such transfers are protected by Standard Contractual Clauses (2021/914/EU) or equivalent safeguards. Request copies at [privacy@vangrid.io](mailto:privacy@vangrid.io). ## 8. Retention * **Filtered captures:** retained for the operational life of the network * **Wallet account data:** retained while account is active plus 90 days after closure * **Access logs:** 12 months * **Takedown-removed content:** 30-day verification hold, then deletion ## 9. Your Rights **GDPR / UK GDPR (EU/UK residents):** Access, rectification, erasure, restriction, portability, objection, and the right to lodge a complaint with your supervisory authority. **CCPA / CPRA (California residents):** Right to know, delete, correct, opt-out of sale/sharing, and limit use of sensitive personal information. We do not "sell" personal information as defined by CCPA. **Brazil (LGPD), Canada (PIPEDA), other jurisdictions:** Equivalent rights honored on request. To exercise any right: [privacy@vangrid.io](mailto:privacy@vangrid.io). ## 10. Children The Service is not intended for anyone under 18. We do not knowingly collect data from minors. Captures depicting identifiable minors must be reported via [privacy@vangrid.io](mailto:privacy@vangrid.io) for immediate removal. ## 11. Takedown & Redaction Any individual whose face, body, vehicle, license plate, residence, or workplace appears in our data (even if already filtered) may request additional obfuscation or removal at [privacy@vangrid.io](mailto:privacy@vangrid.io). We process valid requests within 30 days. No account required. ## 12. Security HTTPS in transit, AES-256 at rest, role-based access controls, and signed URLs for media access. No system is 100% secure; you contribute at your own risk. ## 13. Third-Party Processors We engage processors including: AWS (storage and compute), Cloudflare (CDN), and bitsCrunch (data infrastructure). Updated processor list available on request. ## 14. Contact For all privacy matters, data subject requests, EU representative inquiries, and breach notifications: [privacy@vangrid.io](mailto:privacy@vangrid.io). ## 15. Updates We may update this Policy. Material changes will be notified in-app. Continued use constitutes acceptance. # Terms of Service Source: https://docs.vangrid.io/legal/terms-of-service Vangrid Terms of Service — last updated May 22, 2026. **Last Updated: May 22, 2026** ## 1. Acceptance & Eligibility By using Vangrid you agree to these Terms. You must be at least 18 years old. If you do not agree or are under 18, do not use the Service. ## 2. Service Description Vangrid operates a decentralized perception network. Contributors voluntarily capture spatial geometry of public spaces using their own devices. Vangrid provides the protocol, processing pipeline, and API access for downstream customers. Contributors are independent operators, not employees, agents, or partners of Vangrid. ## 3. Contributor Obligations You are solely responsible for the legality of every capture you submit. You must NOT capture or upload content that: * Is captured on private property or in any space where people have a reasonable expectation of privacy * Includes the interior of homes, vehicles, private offices, hotel rooms, or restrooms * Depicts schools, daycares, playgrounds, healthcare facilities, places of worship, military or government restricted zones, or critical infrastructure perimeters * Identifiably depicts minors (under 18), even incidentally * Is captured in jurisdictions where street-level imagery collection is prohibited * Is fabricated, manipulated, staged, or AI-generated * Violates any local, state, national, or international law applicable to you * Infringes any third party's intellectual property, image rights, or publicity rights You are solely responsible for understanding and complying with the recording laws of your jurisdiction. ## 4. Content License You retain ownership of your original captures. By uploading, you grant Vangrid a worldwide, non-exclusive, royalty-free, sublicensable, transferable license to process, store, derive spatial geometry from, distribute, and commercialize the captured data and any derivatives, for the maximum term permitted by law. You waive any moral rights in derivative spatial data to the extent permitted by law. ## 5. Edge-Computed Privacy Filter Faces, license plates, and human bodies are detected and obscured on your device before any data is transmitted to Vangrid. Vangrid does not receive, store, or have technical access to unprocessed video. You acknowledge that no automated system is perfect and you remain responsible for not capturing content that should not be recorded. ## 6. Points & Rewards Points (PTC) are non-monetary protocol credits earned for valid contributions. PTC: * Have no inherent monetary value, no redemption guarantee, no investment expectation * Are not securities, currency, or financial instruments * May be revoked, adjusted, or invalidated for fraud, manipulation, or violation of these Terms * May be subject to clawback if associated content is later found in breach Vangrid reserves the right to modify the points system, reward rates, and eligibility criteria at any time. ## 7. Access Codes Upload functionality requires a valid access code distributed at Vangrid's sole discretion via official channels. Codes are non-transferable, non-resellable, single-account use. Sharing, selling, or farming codes results in immediate account termination and forfeiture of accumulated PTC. ## 8. Prohibited Conduct You will not: * Use bots, automated tools, fabricated GPS data, or spoofed locations * Reverse-engineer, decompile, or attempt to bypass the privacy filter * Use the Service in any jurisdiction where it is unlawful * Submit content captured by others without authorization * Harass, threaten, or stalk any person through Service use ## 9. Indemnification You agree to indemnify and hold harmless Vangrid, its affiliates, officers, employees, and contractors from any claim, loss, damage, or expense (including legal fees) arising from your captures, your conduct, your violation of these Terms, or your violation of any third-party rights or laws. ## 10. Account Termination Vangrid may suspend, terminate, or restrict your account at any time, with or without notice, for any reason including breach of these Terms, suspicion of fraud, or to comply with legal obligations. ## 11. Takedown Requests Any person depicted or affected may request removal or further obfuscation of specific content at [privacy@vangrid.io](mailto:privacy@vangrid.io). Valid takedown requests are processed within 30 days. DMCA notices to [dmca@vangrid.io](mailto:dmca@vangrid.io). ## 12. Disclaimer of Warranties THE SERVICE IS PROVIDED "AS IS" AND "AS AVAILABLE" WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING MERCHANTABILITY, FITNESS FOR PURPOSE, OR NON-INFRINGEMENT. VANGRID DOES NOT WARRANT UNINTERRUPTED OR ERROR-FREE OPERATION. ## 13. Limitation of Liability TO THE MAXIMUM EXTENT PERMITTED BY LAW, VANGRID'S AGGREGATE LIABILITY SHALL NOT EXCEED ONE HUNDRED USD (\$100). VANGRID IS NOT LIABLE FOR INDIRECT, INCIDENTAL, CONSEQUENTIAL, PUNITIVE, OR SPECIAL DAMAGES. ## 14. Arbitration & Class Action Waiver Any dispute will be resolved by binding individual arbitration administered by the American Arbitration Association under its rules, seated in the British Virgin Islands, in English. YOU WAIVE ANY RIGHT TO PARTICIPATE IN A CLASS ACTION, CLASS ARBITRATION, OR REPRESENTATIVE PROCEEDING. Either party may seek injunctive relief in court for IP or confidentiality matters. ## 15. Geographic Restrictions The Service is not offered to and may not be used by residents of: Illinois (USA), Texas (USA), Washington (USA), Germany, France, Italy, mainland China, Russia, Iran, North Korea, Syria, Cuba, Crimea, and any other jurisdiction where the Service would be unlawful or restricted. It is your responsibility to ensure your use is lawful in your location. ## 16. Independent Contractor You and Vangrid are independent contracting parties. Nothing in these Terms creates an employment, partnership, joint venture, franchise, or agency relationship. ## 17. Modifications We may update these Terms at any time. Material changes will be notified via the Service. Continued use constitutes acceptance. ## 18. Governing Law These Terms are governed by the laws of the British Virgin Islands, without regard to conflict of laws. Subject to Section 14, exclusive jurisdiction lies with the courts of the British Virgin Islands. ## 19. Entire Agreement & Severability These Terms, together with the Privacy Policy, constitute the entire agreement. If any provision is held unenforceable, the remainder remains in effect. *** Contact: [legal@vangrid.io](mailto:legal@vangrid.io) # Pricing Source: https://docs.vangrid.io/pricing Access is early and scoped per deployment. Contact sales. Vangrid is an enterprise platform. Pricing is scoped to your deployment, coverage area, query volume, streaming throughput, and data sovereignty requirements all factor in. Email [**hello@vangrid.io**](mailto:hello@vangrid.io) with a brief description of your use case and we'll get back to you with a tailored proposal. ## What pricing covers * **Spatial query volume**, number of `/v1/spatial/query` calls per month * **Streaming throughput**, concurrent streams and event volume * **Data ingestion**, video upload volume and processing * **Coverage regions**, geographic scope authorized for your account * **Service level**, agreed in the enterprise contract * **Sovereign deployments**, dedicated infrastructure for defense and government customers ## Early access Vangrid is currently in early access. Pilots are evaluated on a case-by-case basis. Priority given to defense primes, robotics fleets, AV labs, and sovereign government programs. Reach out at [hello@vangrid.io](mailto:hello@vangrid.io). # Token utility Source: https://docs.vangrid.io/protocol/token-utility $VAN is the collateral and settlement asset of the Vangrid network. What it is used for, and what it is not. \$VAN is the collateral and settlement asset of the Vangrid network. Its function is operational. This page describes that function and nothing else. Nothing on this page is an offer, a projection, or a statement about price. \$VAN is not live. Every section below is written in the future tense and describes designed function. ## Why the network needs an asset at all Vangrid sells data whose value depends entirely on whether a buyer can believe it was captured where and when it claims. That requirement produces three constraints that a centralised stack does not satisfy: * **Authenticity cannot rest on Vangrid's word.** A buyer evaluating crowd captured data has to be able to verify it without trusting the party selling it. * **Settlement has to clear in minutes, in any jurisdiction, at amounts below a dollar.** No banking rail carries that profile. * **Provenance has to be anchored where no party to the transaction can rewrite it.** \$VAN exists to satisfy those constraints. The order of the sections below reflects their weight. ## Verification collateral Capture authenticity is the network's core problem, and it is the token's primary function. Automated checks at ingest catch the cheap attacks: replays, duplicates, captures whose camera and location signals contradict each other. They cannot resolve the harder cases, and a central review team is both a bottleneck and a single point of trust. Verification is therefore delegated to independent operators who put capital behind their judgement. The mechanism: * Operators stake \$VAN to enter the verification set. The stake is the collateral behind every attestation they sign. * Captures are sampled and assigned pseudorandomly. An operator cannot select which captures to review, and a contributor cannot select the operator who reviews theirs. * Operators sign an attestation of authenticity. The attestation is attached to the capture's provenance record and travels with the observation through the API. * An attestation that disagrees with the resolved outcome costs the operator part of the stake. Sustained disagreement removes the operator from the set. * Failing to act on assigned work carries its own penalty. Idle collateral does not accumulate anything. * Queries that require the highest assurance route fees to the operators who verified the observations returned. The consequence for a buyer: a provenance record is not a claim Vangrid makes about itself. It is a claim an identified operator was paid to make, under collateral that is forfeited if the claim is false. ## Settlement of commissioned capture Bounties will be funded and settled in \$VAN. A reward will move from a requester in one jurisdiction to a contributor in another within minutes of acceptance, at amounts a wire cannot carry economically. Settlement volume therefore tracks work performed. A bounty that nobody fulfils settles nothing. ## Fee denomination The platform fee will be payable in \$VAN at a lower rate than payment by card. Requesters operating continuously on the network hold and spend \$VAN because it is the cheaper path, not because they are asked to. ## Coverage funding Fees collected in \$VAN fund bounties posted by Vangrid in areas the network does not cover. Demand side fees become supply side incentive, directed at the gaps rather than distributed evenly. This is the network's growth mechanism. It is not a distribution to holders. ## Access and residency Region scoped access to the data rail, dedicated residency configurations, and priority placement for bounties will be denominated in \$VAN. ## What \$VAN is not * It is not a claim on revenue, profit, or assets of any entity. * It does not entitle a holder to a distribution of any kind. * Holding it produces nothing. Compensation in the verification set is payment for work performed under collateral, not a return on the collateral. * Points are a separate, non monetary measure of contribution. Points do not convert into \$VAN. # How verification works Source: https://docs.vangrid.io/protocol/verification Checks at ingest, the capture fingerprint, anchoring on Base, and the verification layers that are not live yet. Crowd captured data is worth nothing to a buyer who cannot distinguish it from fabrication. Verification is therefore not a feature of Vangrid, it is the condition under which the data has value at all. Vangrid verifies captures in layers, from cheapest and most automatic to most expensive and most adversarial. Three layers are live. The rest are marked as not live yet and written in the future tense. ## Live: checks at ingest Every capture is validated when it arrives, before it can be submitted to a bounty: * Video quality and length * Consistency between the camera and location signals * Duplicate detection against captures already in the network Submissions that fail are rejected with a reason. ## Live: the capture fingerprint Every capture is fingerprinted as it is recorded. The fingerprint contains a hash of the content, a coarse geohash, and a timestamp. The footage itself is never part of it. Only the fingerprint is derived, which means a capture can be proven unaltered without anyone seeing what it shows. Anyone holding a capture can recompute the hash and compare it against the record. Altered or fabricated data fails that check. ## Live: the fingerprint anchored on Base Fingerprints are accumulated over a short window and committed together as a Merkle tree. The root of that tree is written to the Base blockchain as an attestation, and a new window closes roughly every quarter of an hour. Batching is what makes anchoring affordable at the rate captures arrive: one transaction carries a whole window rather than one transaction per capture. It costs a small amount of temporal resolution, since the chain establishes that a fingerprint existed by the end of its window rather than to the second. What a holder gets in return is an inclusion proof. Given a capture and the short sequence of sibling hashes that accompanies its record, anyone can recompute the root and compare it against the one published on chain. The check terminates against the public ledger rather than against an assurance from the party selling the data, and no step of it requires a response from Vangrid. Anchoring proves existence, ordering and integrity. It does not by itself prove that the scene is what it claims to be. The layers below address that. Contributors manage none of this. No wallet pop ups, no gas, no waiting. ## Not live yet: device attestation at capture time Hardware backed attestation will confirm that a capture originated on a genuine, unmodified device before it is accepted. Until it ships, the fingerprint records what was captured and when, and says nothing about the device that produced it. ## Not live yet: sensor cross correlation Camera, GPS and motion signals will be checked against each other, so that a spoofed location fails a physics check rather than a policy check. ## Not live yet: independent verification under collateral Automated checks resolve the cheap attacks. They cannot resolve a capture that is technically well formed and substantively false, and a central review team is both a bottleneck and a single point of trust. Verification of those cases will be delegated to independent operators. Captures will be sampled and assigned pseudorandomly, so neither side chooses the other. Operators will sign attestations that attach to the capture's provenance record, backed by collateral that is forfeited when an attestation is found false. The point is not decentralisation for its own sake. It is that a buyer auditing a provenance record should be reading a claim someone was paid to make and can be penalised for making falsely, rather than an assurance from the party selling the data. See [Token utility](/protocol/token-utility) for the mechanism. # Quickstart Source: https://docs.vangrid.io/quickstart Connect a wallet, record a capture, submit it to a bounty, get paid. Start at [app.vangrid.io](https://app.vangrid.io). It has two doors: **Capture Data** for contributors, **Buy Data** for organisations commissioning captures. **Capture Data** opens the capture app at [app.vangrid.io/capture](https://app.vangrid.io/capture). It runs in any browser with no installation. On Android you can install it from [Google Play](https://play.google.com/store/apps/details?id=io.vangrid.app) instead, it is the same app. **Buy Data** opens [data.vangrid.io](https://data.vangrid.io), where bounties are posted and fulfilled. Your wallet is your sign in. There is no email and no password. You need one to upload captures. You do not need one to browse bounties. Open [data.vangrid.io](https://data.vangrid.io), read what a bounty asks for, where, and how long it stays open. Follow the [capture guidance](/contribute/capture), then submit your clip to the bounty before its deadline. If the requester accepts your submission, Vangrid pays you the reward. # Service levels Source: https://docs.vangrid.io/sla Service level terms are set in the enterprise agreement for each deployment. Service level terms are set in the enterprise agreement for each deployment, and scoped to the regions and workloads it covers. Email [hello@vangrid.io](mailto:hello@vangrid.io) with your availability and support requirements. ## What a service level covers * Availability of the spatial query, ingestion and streaming endpoints * Availability of authentication and key management * Support response commitments ## Exclusions Service levels do not cover scheduled maintenance windows, announced in advance, force majeure events, or coverage density in any specific geographic area. Coverage is a function of contributor activity in that area, not of infrastructure availability. Where a place is not covered, commission it with a [bounty](/contribute/bounties). ## Incidents Report an active incident to [hello@vangrid.io](mailto:hello@vangrid.io). # Autonomous logistics Source: https://docs.vangrid.io/use-cases/autonomous-logistics Spatial awareness for routing, obstacle detection and fleet coordination. The API is in early access and is not publicly available. Endpoint URLs, request examples and sample responses on this page are illustrative. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request access. Autonomous logistics platforms, delivery robots, autonomous vehicles, drone fleets, share a common dependency: they need accurate, continuously updated knowledge of the physical environment around them. Vangrid gives your systems that foundation by streaming verified spatial ground truth from a dense network of edge nodes already operating in urban environments, so your vehicles can route safely, detect obstacles in real time, and coordinate across a fleet without relying on stale map data. ## Key challenges Vangrid solves Detect transient obstacles, parked vehicles, construction zones, pedestrian congestion, the moment they appear, not on the next map update cycle. Validate planned routes against live spatial conditions before and during traversal. Know whether a corridor is passable before your vehicle commits to it. Give every vehicle in your fleet access to the same real-time spatial picture so they can negotiate intersections, share lanes, and avoid redundant paths. ## How Vangrid fits into a logistics stack Vangrid sits between your physical fleet and your routing or decision layer. Your vehicles issue spatial queries to define their area of interest, receive ground truth responses with confidence scores, and update their onboard world models continuously. Because Vangrid edge nodes operate at tactical urban density, even narrow corridors and interior loading docks are covered. Urban-density edge node coverage is available in supported metro areas. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to confirm coverage for your deployment zone. ## Use case walkthrough: last-mile delivery corridor The following walkthrough shows how to integrate Vangrid into a last-mile delivery system operating in a dense urban block. Model your delivery route as a GeoJSON polygon that encloses the street corridor your vehicle will traverse. Use a polygon tight enough to avoid pulling data from unrelated blocks, but wide enough to cover the full width of the path plus a safety margin. ```json delivery-corridor.json theme={"dark"} { "type": "Polygon", "coordinates": [[ [-73.9865, 40.7480], [-73.9845, 40.7480], [-73.9845, 40.7510], [-73.9865, 40.7510], [-73.9865, 40.7480] ]] } ``` Submit a spatial query against `/v1/spatial/query` with your corridor polygon and a `ground_truth_score` threshold to filter out low-confidence observations. Setting `max_age_seconds` keeps the response current, for active navigation, values between 10 and 30 seconds are typical. ```bash curl theme={"dark"} curl -X POST https://api.vangrid.io/v1/spatial/query \ -H "Authorization: Bearer $VANGRID_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "aoi": { "type": "Polygon", "coordinates": [[ [-73.9865, 40.7480], [-73.9845, 40.7480], [-73.9845, 40.7510], [-73.9865, 40.7510], [-73.9865, 40.7480] ]] }, "max_age_seconds": 15, "min_ground_truth_score": 0.90 }' ``` ```python python theme={"dark"} import os import requests api_key = os.environ["VANGRID_API_KEY"] corridor = { "type": "Polygon", "coordinates": [[ [-73.9865, 40.7480], [-73.9845, 40.7480], [-73.9845, 40.7510], [-73.9865, 40.7510], [-73.9865, 40.7480], ]], } payload = { "aoi": corridor, "max_age_seconds": 15, "min_ground_truth_score": 0.90, } response = requests.post( "https://api.vangrid.io/v1/spatial/query", headers={ "Authorization": f"Bearer {api_key}", "Content-Type": "application/json", }, json=payload, ) data = response.json() print(f"Ground truth score: {data['ground_truth_score']}") print(f"Observations: {len(data['data_points'])}") ``` The response includes a top-level `ground_truth_score` for the entire AOI and individual observations from each contributing edge node. Your routing layer should inspect both the aggregate score and the spatial distribution of `data_points` to identify specific segments with blocked or degraded conditions. ```json theme={"dark"} { "query_id": "q_2d7b9f4e1a3c8605", "timestamp": "2026-05-22T09:14:33.201Z", "node_count": 312, "ground_truth_score": 0.96, "geometry": { "type": "Polygon", "coordinates": [[ [-73.9865, 40.7480], [-73.9845, 40.7480], [-73.9845, 40.7510], [-73.9865, 40.7510], [-73.9865, 40.7480] ]] }, "data_points": [ { "node_id": "node_9c3f1a", "lat": 40.7492, "lon": -73.9857, "observation": "clear", "confidence": 0.98, "captured_at": "2026-05-22T09:14:32.774Z", "provenance_hash": "sha256:b7e2d4f1a9c3605ef1d8b4a2c7f9e3b1d4a7f2c9" }, { "node_id": "node_2a8e5c", "lat": 40.7501, "lon": -73.9851, "observation": "obstruction_detected", "confidence": 0.94, "captured_at": "2026-05-22T09:14:33.012Z", "provenance_hash": "sha256:c4f1a9e2d7b3605fa1d9c4b2f7e4a1c9d3b7f1a2" } ], "provenance_hash": "sha256:a1c9d3b7f4e2605fb9d1c4a2e7f3b1a9c4d7e2f1" } ``` Parse `data_points` for observations with `observation: "obstruction_detected"` and route around their coordinates before dispatching your vehicle. A `ground_truth_score` below 0.85 across the full AOI suggests the corridor has high environmental uncertainty, consider holding the vehicle until scores recover. Once a vehicle is in motion, replace periodic queries with a streaming subscription so your onboard system receives updates as conditions change rather than on a fixed polling interval. ```python python theme={"dark"} import os import json import requests api_key = os.environ["VANGRID_API_KEY"] params = { "geometry": "POLYGON((-73.9865 40.7480,-73.9845 40.7480,-73.9845 40.7510,-73.9865 40.7510,-73.9865 40.7480))", "ground_truth_score_min": "0.90", } with requests.get( "https://api.vangrid.io/v1/spatial/stream", headers={ "Authorization": f"Bearer {api_key}", "Accept": "text/event-stream", }, params=params, stream=True, ) as response: for line in response.iter_lines(): if line: event = json.loads(line.decode("utf-8").lstrip("data: ")) # Feed each update into your onboard world model process_spatial_update(event) ``` ## Relevant concepts How urban-density edge node coverage is structured and how nodes are selected for your queries. What `ground_truth_score` means, how it is calculated, and when to trust or reject a response. How data moves from edge capture through multi-view ingestion to your API response. # Critical infrastructure Source: https://docs.vangrid.io/use-cases/critical-infrastructure Continuous monitoring of physical environments and assets. The API is in early access and is not publicly available. Endpoint URLs, request examples and sample responses on this page are illustrative. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request access. Power grids, water systems, transportation networks, and industrial facilities share a common vulnerability: physical change, an intrusion, equipment failure, or environmental shift, can escalate into a serious incident within minutes. Traditional monitoring relies on scheduled inspections or sparse fixed cameras that miss transient events entirely. Vangrid gives your operations team continuous spatial ground truth over any defined geographic zone, so anomalies are detected the moment they appear and your systems can respond before an incident compounds. ## Key capabilities for infrastructure monitoring Edge nodes stream observations continuously. Your monitoring system always has a current spatial picture of the area, not a snapshot from the last scheduled scan. Compare incoming observations against a known baseline to identify deviations, new objects, removed infrastructure, access-point breaches, or environmental changes like flooding. The Vangrid streaming API delivers Server-Sent Events so your alerting and SCADA systems receive spatial updates in real time over a persistent connection without polling. Define your monitoring zone with a precise GeoJSON polygon, a substation perimeter, a pipeline corridor, a port facility, and receive observations scoped exactly to that area. ## Infrastructure types supported Vangrid's edge network covers a range of physical infrastructure environments: Monitor substation perimeters, transmission corridor right-of-ways, and generation facility boundaries. Detect unauthorized access, equipment displacement, or vegetation encroachment in real time. Maintain continuous spatial awareness of facility perimeters and intake zones. Identify physical access events or structural changes that could indicate tampering or damage. Stream ground truth over rail corridors, highway segments, and port facilities. Detect stopped vehicles, track intrusions, or identify infrastructure damage affecting operations. Monitor large-footprint industrial sites where perimeter length makes physical patrol impractical. Receive spatial change alerts the moment conditions deviate from a known-good baseline. ## Use case walkthrough: infrastructure perimeter monitoring This walkthrough sets up a streaming spatial subscription for a power substation perimeter and routes anomaly events to your alert system. Model the infrastructure perimeter as a GeoJSON polygon. For a substation, this is typically the fence line plus a small outer buffer. Keep the polygon as tight as practical, a focused AOI reduces noise and keeps the `ground_truth_score` high by concentrating node coverage. ```json substation-perimeter.json theme={"dark"} { "type": "Polygon", "coordinates": [[ [-87.6520, 41.8340], [-87.6490, 41.8340], [-87.6490, 41.8370], [-87.6520, 41.8370], [-87.6520, 41.8340] ]] } ``` Open a persistent streaming connection to `/v1/spatial/stream` with your perimeter polygon. Set a `ground_truth_score_min` threshold to suppress low-confidence observations before they reach your alert logic. ```bash curl theme={"dark"} curl -N -X GET \ "https://api.vangrid.io/v1/spatial/stream?geometry=POLYGON((-87.6520+41.8340,-87.6490+41.8340,-87.6490+41.8370,-87.6520+41.8370,-87.6520+41.8340))&ground_truth_score_min=0.92" \ -H "Authorization: Bearer $VANGRID_API_KEY" \ -H "Accept: text/event-stream" ``` ```python python theme={"dark"} import os import json import requests api_key = os.environ["VANGRID_API_KEY"] params = { "geometry": ( "POLYGON((-87.6520 41.8340,-87.6490 41.8340," "-87.6490 41.8370,-87.6520 41.8370,-87.6520 41.8340))" ), "ground_truth_score_min": "0.92", } with requests.get( "https://api.vangrid.io/v1/spatial/stream", headers={ "Authorization": f"Bearer {api_key}", "Accept": "text/event-stream", }, params=params, stream=True, ) as response: for line in response.iter_lines(): if line: raw = line.decode("utf-8") if raw.startswith("data: "): event = json.loads(raw[6:]) handle_spatial_event(event) ``` Each streamed event includes an array of `data_points`. Inspect each point's `observation` field for values that indicate a change from the expected state. Route anomalous observations to your incident management or SCADA system. ```python python theme={"dark"} def handle_spatial_event(event): anomaly_observations = { "obstruction_detected", "unauthorized_access", "structural_change", "perimeter_breach", } for point in event.get("data_points", []): if point["observation"] in anomaly_observations: trigger_alert( zone="substation-perimeter", observation=point["observation"], lat=point["lat"], lon=point["lon"], confidence=point["confidence"], provenance_hash=point["provenance_hash"], captured_at=point["captured_at"], ) ``` Store the `provenance_hash` from every anomaly event alongside your incident record. This gives you a tamper-evident audit trail that you can use for post-incident review, regulatory reporting, or legal proceedings. If a streaming connection drops, due to network conditions or a maintenance window, your monitoring system should fall back to polling `/v1/spatial/query` on a short interval until the stream reconnects. This ensures you have no unmonitored windows during the transition. ```python python theme={"dark"} import time def poll_until_stream_reconnects(geometry, interval_seconds=10): while True: response = requests.post( "https://api.vangrid.io/v1/spatial/query", headers={ "Authorization": f"Bearer {os.environ['VANGRID_API_KEY']}", "Content-Type": "application/json", }, json={ "aoi": geometry, "max_age_seconds": interval_seconds, "min_ground_truth_score": 0.92, }, ) handle_spatial_event(response.json()) time.sleep(interval_seconds) ``` ## Example streaming event A typical streaming event for a perimeter monitoring subscription looks like this: ```json theme={"dark"} { "query_id": "stream_7c4a1f9e2d3b8605", "timestamp": "2026-05-22T07:33:15.882Z", "node_count": 88, "ground_truth_score": 0.95, "data_points": [ { "node_id": "node_1d7c4f", "lat": 41.8352, "lon": -87.6508, "observation": "clear", "confidence": 0.97, "captured_at": "2026-05-22T07:33:15.441Z", "provenance_hash": "sha256:d1a9f3e7c4b2605ae9d1c4f3b7a2e1d9c4f7a3e2" }, { "node_id": "node_8a2e6b", "lat": 41.8361, "lon": -87.6513, "observation": "perimeter_breach", "confidence": 0.93, "captured_at": "2026-05-22T07:33:15.709Z", "provenance_hash": "sha256:f3a1d9e7b4c2605fd1a9c4e3b7f2a1d9e4c7b3f1" } ], "provenance_hash": "sha256:e4b7f1c9a3d2605be4c7a1f9d3b2e7c4a1d9f3b2" } ``` A streaming event with `ground_truth_score` below 0.80 means fewer than the expected number of edge nodes contributed observations for that interval. Do not suppress alerts during low-score periods, treat them as periods of reduced visibility and increase your alert sensitivity accordingly. ## Relevant concepts How `ground_truth_score` is calculated and what thresholds are appropriate for monitoring applications. How observations move from edge capture to your streaming endpoint, including latency characteristics. How to use `provenance_hash` values for audit trails and post-incident verification. # Embodied AI Source: https://docs.vangrid.io/use-cases/embodied-ai Continuous spatial ground truth for robots and physical agents. The API is in early access and is not publicly available. Endpoint URLs, request examples and sample responses on this page are illustrative. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request access. Embodied AI systems, humanoid robots, drone swarms, autonomous industrial equipment, require a persistent, continuously updated model of the physical world to operate safely and effectively. Vangrid supplies the spatial cortex: a real-time stream of verified ground truth observations from the network that your system can ingest to keep its world model current. ## What embodied AI needs from spatial data A world model is only as good as its inputs. Vangrid addresses three core requirements: * **Continuous updates**, the physical world changes constantly; your world model must too * **Verified observations**, every data point carries a `provenance_hash` so your system can trust what it receives * **High spatial density**, tactical urban coverage means enough node overlap to corroborate observations and eliminate false positives ## Streaming spatial updates into your world model Use the Vangrid Streaming API to subscribe to a geographic zone and receive push updates as ground truth changes. Specify the geographic polygon your system operates within. Keep the AOI tight to reduce update volume and latency. Connect to the streaming endpoint with your API key. Updates arrive as newline-delimited JSON. Parse each event and update your spatial representation. Use `ground_truth_score` to weight observations. For safety-critical decisions, verify the `provenance_hash` before acting on an observation. ```python Python theme={"dark"} import requests import json API_KEY = "your-api-key" BASE_URL = "https://api.vangrid.io/v1" aoi = { "type": "Polygon", "coordinates": [[ [-122.4194, 37.7749], [-122.4094, 37.7749], [-122.4094, 37.7849], [-122.4194, 37.7849], [-122.4194, 37.7749] ]] } with requests.post( f"{BASE_URL}/spatial/stream", headers={"Authorization": f"Bearer {API_KEY}"}, json={"aoi": aoi, "min_ground_truth_score": 0.80}, stream=True ) as response: for line in response.iter_lines(): if line: event = json.loads(line) # Ingest into world model update_world_model(event) ``` ## Key data fields for embodied AI Each streaming event includes: | Field | Type | Description | | - | - | - | | `geometry` | GeoJSON | Location and shape of the observed feature | | `ground_truth_score` | float (0–1) | Multi-node corroboration confidence | | `timestamp` | ISO 8601 | When the observation was captured | | `provenance_hash` | string | Cryptographic proof of data origin | | `node_count` | integer | Number of edge nodes that contributed | | `observation_type` | string | Category of observation (obstacle, occupancy, change) | For real-time navigation, filter to `ground_truth_score >= 0.75`. For safety-critical actions (grasping, human interaction), require `ground_truth_score >= 0.90`. ## Example streaming event ```json theme={"dark"} { "event_id": "evt_8f3a2c1d", "timestamp": "2026-05-22T10:14:33.412Z", "geometry": { "type": "Point", "coordinates": [-122.4150, 37.7800] }, "observation_type": "obstacle", "ground_truth_score": 0.94, "node_count": 12, "provenance_hash": "sha256:a3f8e2c1b4d7f9e0a2b5c8d1e4f7a0b3c6d9e2f5" } ``` Contact [hello@vangrid.io](mailto:hello@vangrid.io) to discuss high-frequency streaming rates and dedicated node allocation for production embodied AI deployments. # Sovereign defense Source: https://docs.vangrid.io/use-cases/sovereign-defense Verified ground level intelligence with auditable provenance. The API is in early access and is not publicly available. Endpoint URLs, request examples and sample responses on this page are illustrative. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to request access. Defense and intelligence applications demand more than accurate spatial data, they require provable data provenance, strict control over where data resides and transits, and verifiable chain of custody from sensor to analyst. Vangrid is built for exactly these requirements. Every observation is cryptographically signed at the edge before transmission, data sovereignty boundaries are enforced at the infrastructure level, and raw sensor streams never leave the originating node. The result is a spatial intelligence platform you can deploy in mission-critical environments with confidence that the data you receive is authentic and has not been intercepted or tampered with. ## Defense-tier capabilities Every data point carries a provenance hash encoding node identity, capture timestamp, and observation content. Any alteration to the data invalidates the hash, giving you tamper-evident proof of integrity from sensor to delivery. Queries are routed exclusively through nodes within your designated sovereignty boundary. Data does not transit infrastructure outside that boundary unless you explicitly authorize cross-region access. Raw sensor streams, imagery, depth data, point clouds, are processed on-device and never transmitted. Only derived spatial features leave the node, enforcing privacy at the hardware layer, not as a software policy. Fine-grained access controls let you restrict which users, systems, or API keys can query specific geographic zones, data tiers, or provenance-verified datasets. ## Defense use cases ### Situational awareness Vangrid streams continuous ground truth over areas of operational interest, giving analysts and command systems a live, corroborated spatial picture without requiring forward-deployed sensor infrastructure. Because observations are cross-validated by multiple independent edge nodes, the `ground_truth_score` gives you a quantitative measure of observational confidence for any given area. ### Border and perimeter monitoring Define a polygon AOI along a border or perimeter and subscribe to a streaming feed. Vangrid delivers observations as they arrive from edge nodes in the zone, so your monitoring systems receive updates in real time rather than on scheduled imagery cycles. ### Critical zone surveillance Establish spatial subscriptions for sensitive zones, installation perimeters, airspace corridors, maritime exclusion areas, and configure alert thresholds based on `ground_truth_score` and observation type. High-confidence anomalies are surfaced immediately; low-confidence signals are flagged for analyst review rather than silently dropped. ## Data sovereignty: how residency and access controls work When you provision a defense-tier Vangrid account, you specify one or more sovereign regions. Vangrid enforces three guarantees within those regions: Your API queries are routed only to edge nodes within your designated sovereign region. No observation data transits nodes or infrastructure outside that boundary. All data moving from edge nodes to the Vangrid aggregation layer and from the aggregation layer to your endpoint is encrypted in transit using TLS 1.3. The provenance hash is computed before encryption and verified after decryption, so any interception or modification is detectable. Every response includes a `provenance_hash` you can store alongside the response data. At any point you can re-verify the hash to confirm the data has not been altered since delivery. This creates an auditable record of every observation your systems consumed. Defense-tier access, sovereign region configuration, and advanced access controls are available through a dedicated enterprise agreement. Contact [hello@vangrid.io](mailto:hello@vangrid.io) to discuss your requirements and initiate onboarding. ## Verifying provenance on a spatial response After receiving a spatial query response, verify its `provenance_hash` to confirm the payload has not been altered. The following example shows how to perform this verification. ```bash curl theme={"dark"} # Step 1: submit a spatial query and capture the response curl -X POST https://api.vangrid.io/v1/spatial/query \ -H "Authorization: Bearer $VANGRID_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "aoi": { "type": "Polygon", "coordinates": [[ [34.7818, 32.0853], [34.7918, 32.0853], [34.7918, 32.0953], [34.7818, 32.0953], [34.7818, 32.0853] ]] }, "max_age_seconds": 60 }' \ -o response.json # Step 2: verify the provenance hash via the verification endpoint curl https://api.vangrid.io/v1/provenance/$(jq -r .provenance_hash response.json) \ -H "Authorization: Bearer $VANGRID_API_KEY" ``` ```python python theme={"dark"} import os import json import requests api_key = os.environ["VANGRID_API_KEY"] headers = { "Authorization": f"Bearer {api_key}", "Content-Type": "application/json", } # Step 1: submit a spatial query query_payload = { "aoi": { "type": "Polygon", "coordinates": [[ [34.7818, 32.0853], [34.7918, 32.0853], [34.7918, 32.0953], [34.7818, 32.0953], [34.7818, 32.0853], ]], }, "max_age_seconds": 60, } response = requests.post( "https://api.vangrid.io/v1/spatial/query", headers=headers, json=query_payload, ) data = response.json() query_id = data["query_id"] provenance_hash = data["provenance_hash"] # Step 2: verify the provenance hash verification = requests.get( f"https://api.vangrid.io/v1/provenance/{provenance_hash}", headers=headers, ) result = verification.json() if result.get("verified"): print(f"Provenance verified for query {query_id}") else: print(f"Verification FAILED: {result.get('reason')}") raise RuntimeError("Data integrity check failed, do not use this response.") ``` A successful verification response looks like this: ```json theme={"dark"} { "query_id": "q_5a3f1c9d2e7b4806", "provenance_hash": "sha256:9e3b1c7f4a2d8605bf1e4d7c2a8f3b9e1c4d7a2f", "verified": true, "node_count": 214, "sovereign_region": "eu-west-1", "captured_at": "2026-05-22T11:47:22.304Z" } ``` If `verified` is `false`, treat the response as untrusted and do not use it in any downstream decision-making. Log the failed verification and contact [hello@vangrid.io](mailto:hello@vangrid.io) if you observe repeated failures. ## Relevant concepts How provenance hashes are constructed, what they encode, and how to use them for audit and verification. How sovereign regions work, how routing is enforced, and how to configure access boundaries for your account. Why raw sensor streams never leave the node and what this means for operating in sensitive environments.