Start building with Tilebox

Tilebox documentation

Start building with Tilebox

Query Earth Data. Build, run, debug, and scale geospatial workflows across environments. One API for humans and agents.

What do you want to build? Ctrl K

Quickstart

Get API Key

Ingest data

Agent

You

Build a reproducible Tilebox workflow that starts with a user-provided CSV of known data centers and then:

• Finds cloud-free Sentinel-2 imagery over a target lat/lon in a time window
• Reads the relevant band products and crops scenes to a 3km area around the target
• Computes the cloud fraction for the cropped area and filters out scenes > 1%
• Compares before/after by scoring visible change based on suitable metrics
• Creates a datacenter site ranking based on score

Use the provided Tilebox skills to research datasets, access storage, outline the workflow, and then implement it. Deploy and run on our GCP cluster, in case of failures inspect runner logs and iterate on the workflow.

Ask your agent to build with Tilebox…↵

CLI

CLI

curl -fsSL https://install.tilebox.com/cli.sh | sh

tilebox dataset query
  open_data.copernicus.sentinel2_msi
  --last 7d
  --spatial-extent 'POLYGON((-109 41,-109 37,-102 37,-102 41,-109 41))'
  --limit 10

tilebox job submit
  --name "Datacenter Monitoring"
  --task "ComputeVisibleChange"
  --input "{\"before\": \"2024-06-01\", \"after\": \"2026-06-01\"}"
  --cluster gcp-Drv6L7Li4t7Yvk

Copy

Python

runner.py

from tilebox.datasets import Client
from tilebox.workflows import ExecutionContext, Runner, Task

class ComputeVisibleChange(Task):
  before: str
  after: str

  def execute(self, context: ExecutionContext):
    sentinel2 = Client().dataset(
      "open_data.copernicus.sentinel2_msi"
    )
    scenes = sentinel2.collection("S2A_S2MSI1A").query(
        temporal_extent=(before, after),
    )
    context.logger.info("Found scenes", n=len(scenes.granule_name))
    context.submit_subtasks([
      ProcessScene(str(name) for name in scenes.granule_name)
    ])

runner = Runner(tasks=[ComputeVisibleChange])

Copy

Go

main.go

type ComputeVisibleChange struct {
    Before time.Time
    After  time.Time
}

func (t *ComputeVisibleChange) Execute(ctx context.Context) error {
    client := datasets.NewClient()
    dataset, _ := client.Datasets.Get(ctx, "open_data.copernicus.sentinel2_msi")
    collection, _ := client.Collections.Get(ctx, dataset.ID, "S2A_S2MSI1C")

    var scenes []*examplesv1.Sentinel2Msi
    _ = client.Datapoints.QueryInto(ctx, dataset.ID, &scenes,
        datasets.WithCollections(collection),
        datasets.WithTemporalExtent(query.NewTimeInterval(t.Before, t.After)),
    )

    slog.InfoContext(ctx, "Found scenes", slog.Int("n", len(scenes)))
    for _, scene := range scenes {
        _, _ = workflows.SubmitSubtask(ctx, &ProcessScene{
            Name: scene.GetGranuleName(),
        })
    }
    return nil
}

Copy

Get started

Choose how you build

Use Tilebox directly as a developer, or give an agent the same tools and documentation context so it can operate Tilebox for you.

Use an agent

Configure a coding agent with the Tilebox CLI, agent skills, and optional MCP access. Agents can inspect datasets, write workflow code, submit jobs, and debug runs with Tilebox context.

Onboard your agent

Create and deploy workflows

Connect with MCP

Build as a developer

Use the Console, Python SDK, Go SDK, and CLI to query data, ingest your own catalogs, create workflow tasks, and run them across your infrastructure.

Quickstart

Choose an SDK

API reference

Learn

Explore the platform

Start from the outcome you need. Tilebox combines typed data access, workflow execution on your infrastructure, and shared observability for people and agents working on geospatial systems.

Query satellite data

Search typed datasets by time, location, collection, custom fields, or datapoint ID.

Inspect workflow runs

Use logs, traces, progress, and job state to debug workflows and verify results.

Deploy to your own compute

Connect runners to your own infrastructure and control where workflow tasks execute.

Browse practical recipes

Find task-focused guides for querying data, building workflows, connecting storage, and operating Tilebox.

Run a workflow Assets and storage Ingest data Sample notebooks Spatio-temporal datasets Jobs

Scale

From query to operational pipelines

Start with open data or your own catalogs, turn processing steps into tasks, and run them where your data and infrastructure already live.

1. Discover and query data

   Query open datasets or your own custom Tilebox datasets by time, area of interest, collection, or datapoint ID.

2. Build workflow tasks

   Turn processing steps into workflow tasks that can submit subtasks, report progress, use caches, and emit logs and traces.

3. Prototype locally

   Develop with local runners, iterate quickly, and prototype your geospatial workflows.

4. Deploy to your own compute

   Run workflows across cloud, on premise, sovereign, air-gapped, or edge environments while Tilebox tracks jobs and distributes work for parallel execution.

5. Inspect and iterate

   Query job state, logs, spans, and progress from the Console, SDKs, CLI, or agent tools.