← Blog

Connect Every.Farm to Claude (or any AI agent)

By The Every.Farm team ·

tutorials api ai

Every.Farm has a full developer API, and that turns out to be the perfect surface for an AI agent. Give Claude — or any agent system that can make HTTP requests — a token and a single URL, and it can list your farms, read datasets and their GeoJSON, push new field observations into a collector, and kick off satellite analyses, all on your behalf.

This post walks through the whole loop: create a token, hand it to an agent, and let the agent discover everything else by itself.

What you'll need

  • An Every.Farm account with at least one farm.
  • An agent that can make authenticated HTTP requests. That includes Claude via the Anthropic API with tool use, Claude Code, an MCP server, or any framework (LangChain, LlamaIndex, a custom script) that can attach an Authorization header. A plain chat window with no tools can't make live calls — the agent needs the ability to hit a URL.

Step 1 — Create an API token

  1. Sign in to Every.Farm, open your account menu, and choose API Tokens.
  2. Click New token and give it a descriptive name (e.g. "Claude — read only").
  3. Choose the scope:
    • read — list and read farms, datasets, GeoJSON, collectors, satellite data. Start here.
    • write — also create datasets, push datapoints, trigger analyses. Add this only when you want the agent to make changes.
  4. Optionally restrict the token to specific farms. If you manage ten farms but only want the agent touching one, lock it down here. The token simply won't see the others.
  5. Copy the efv_... token. It's shown only once.

Treat the token like a password. It carries exactly the access you granted and nothing more, and you can revoke it from the same page the instant you're done — or if it ever leaks.

Step 2 — Hand the token to your agent

How you pass the token depends on your setup, but the shape is always the same: the agent sends it as a Bearer header on every request.

Authorization: Bearer efv_xxxxxxxx_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

A typical instruction to an agent looks like this:

You have access to the Every.Farm API. The base URL is https://api.every.farm/v1 and your token is efv_.... Send the token as an Authorization: Bearer header on every request. Start by fetching GET https://api.every.farm/v1 to discover what's available.

If you're wiring this up in code — say, Claude with a fetch-style tool — the token lives in an environment variable, never in the prompt:

import os, requests

BASE = "https://api.every.farm/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['EVERY_FARM_API_TOKEN']}"}

# The agent's first move: discover the API.
manifest = requests.get(BASE, headers=HEADERS, timeout=30).json()
print(manifest["documentation"])   # link to the full reference
print([e["path"] for e in manifest["endpoints"]])

Step 3 — Let the agent discover the rest

This is the part that makes agents work well with Every.Farm: the API describes itself. A GET to the base URL returns a manifest of every endpoint, what each one does, how authentication works, and a link to the full human-readable docs.

GET https://api.every.farm/v1

{
  "name": "Every.Farm Developer API",
  "version": "v1",
  "documentation": "https://everyfarm.notion.site/Developer-API-Documentation-67c9dde72ad683749f7c017fd202e6e3",
  "authentication": {
    "scheme": "Bearer",
    "header": "Authorization: Bearer efv_...",
    "howToGetAToken": "Sign in to Every.Farm, open the API Tokens panel from your account menu, and create a token."
  },
  "conventions": {
    "baseUrl": "https://api.every.farm/v1",
    "signedUrls": "GeoJSON / raster / image URLs are short-lived signed URLs. Re-request to refresh.",
    "rateLimits": "Default 60 requests/minute and 10,000 requests/day per token."
  },
  "endpoints": [
    { "method": "GET",  "path": "/v1/farms", "summary": "List farms the token can access." },
    { "method": "GET",  "path": "/v1/datasets/:dataset_id/geojson", "summary": "Full GeoJSON. ?resolve_images=true signs image fields." },
    { "method": "POST", "path": "/v1/collectors/:collector_id/datapoints", "summary": "Push one or many datapoints." },
    "… and the rest of the API"
  ]
}

Because the manifest carries the documentation URL, you don't have to remember it or paste it into every prompt — the agent finds it the moment it makes its first call. (For the record, the full reference lives at the Notion link above, and it's worth a read if you're building something more involved.)

So the entire setup you give an agent is really just two things: the token and https://api.every.farm/v1. Everything else is self-service.

A worked example

Here's the kind of thing an agent can do once it's connected. The prompt:

Look at my "Lakeview Vineyard" farm. List its datasets, then summarize the most recent Sentinel-2 NDVI dataset — how many data points, and the value range.

Under the hood the agent makes three calls, all of which it learned from the manifest:

GET /v1/farms
  → finds the farm id

GET /v1/farms/{farm_id}/datasets
  → lists datasets, picks the newest NDVI one

GET /v1/datasets/{dataset_id}/geojson
  → reads the GeoJSON, counts features, computes the value range

…and reports back in plain language. No glue code from you — the agent chose those endpoints itself.

What agents can do with each scope

Read scope is enough for analysis and reporting:

  • Inventory farms, blocks, folders, and datasets.
  • Pull any dataset's GeoJSON — including signed URLs for any field photos attached to collector datapoints.
  • Download raster datasets (NDVI, true-color composites) as Cloud Optimized GeoTIFFs.
  • Browse satellite scenes and read prior analysis jobs.

Write scope lets the agent contribute data back:

  • Create a dataset from GeoJSON it generated.
  • Spin up a data collector with a custom field schema, push datapoints (sensor readings, scouting notes, observations), and recompile them into a live dataset.
  • Trigger satellite analyses — say, a temporal-mean NDVI over a date range — and poll the job until the dataset is ready.

A sensor gateway, a scouting app, or an autonomous monitoring agent all fit naturally into the write endpoints.

Keeping it safe

  • Scope minimally. Give read-only unless the agent genuinely needs to write. You can always issue a second token later.
  • Restrict to farms. A token locked to one farm can't touch the rest of your account, even if it's mishandled.
  • Rotate freely. Tokens are cheap. Revoke and reissue whenever you hand work to a new agent or finish a project. Revocation is instant.
  • Never paste a token into a shared chat or commit it to a repo. Keep it in an environment variable or a secrets manager. If one ever ends up somewhere it shouldn't, revoke it from the API Tokens panel and generate a new one.

Every request is authenticated and scoped to the farms you actually have access to — the same permission model the app itself uses. An agent can never see a farm you can't.

What's next

Point an agent at https://api.every.farm/v1, give it a read-only token, and ask it about your farms. Once you've watched it navigate the data on its own, the write endpoints open up a lot: agents that log observations, sensors that stream into collectors, scheduled jobs that keep a satellite index up to date across the season.

The full API reference — every parameter, every response shape — is in the Developer API Documentation. But the nice part is you can hand an agent far less than that and it'll figure out the rest.

Want to try this on your own farm? Open Every.Farm — it's free while we're in research-platform mode.