You have the files. Now what?

Drop a file. Get a geospatial API.

GeoTIFFs, GeoPackages, shapefiles, CSV sensor readings: Tilo turns each file into map tiles, queryable features and a STAC catalogue, behind one authenticated API. No server to run, no tiling pipeline to maintain, no bucket to secure, whether the file comes from a researcher, a script or an AI agent.

Create a free account Open the console

No card required. Hosted in Paris, on Scaleway.

Every layer answers the same API A cross-section of stacked data layers: your satellite scenes, your sensor readings, a shared relief raster and shared country borders, with room for your next dataset. A single request to api.tilo.lumina.ooo reaches down through all of them and gets tiles or features from each. Satellite scenes yours, dated per acquisition Sensor readings yours, points Relief shared catalogue, raster Country borders shared catalogue, vector Your next dataset api.tilo.lumina.ooo tiles features tiles features
Your data and the shared catalogue answer the same grammar: STAC for finding a layer, OGC API for reading it.

See it work

Air-quality readings and a satellite image: from a folder of files to an API that a notebook, a colleague or an agent can open.

Narrated, with subtitles. Everything shown in the product is a real session against production with a demo account: the agent, the API calls and the console. Data: contains modified Copernicus Sentinel-5P data (2026); air quality © Sensor.Community contributors, ODbL; borders from Natural Earth.

Drop it. It's served.

You bring files. Tilo does the part that usually needs a GIS server, a tiling pipeline, a bucket and someone to run them.

  1. Drop the file

    One authenticated call to the API, from the console, a script, the tilo CLI or an agent. GeoJSON, CSV, Shapefile, GeoPackage, GML, KML or GeoTIFF.

  2. Tilo runs the infrastructure

    Vector data becomes tiles and queryable features; rasters become Cloud-Optimized GeoTIFFs on the web-map grid. Every version is validated before it is served, and every version is kept.

  3. Open it anywhere

    Each dataset gets STAC and OGC API endpoints that QGIS, GDAL, rasterio, pystac-client and web maps read directly. Share it with an API key, or with a link that expires on the date you choose.

The API is the product

The console, the tilo CLI, the Go SDK and the MCP server are ordinary clients of one public API, documented in OpenAPI. Anything they do, your code can do.

  • One command, if you want one

    The CLI uploads the file, waits for validation and publishes it. It holds no logic of its own and prints the API's JSON, ready for jq.

    $ tilo push no2-2026-09.tif --publish --wait
    Authenticated by an API key in TILO_API_KEY.

  • Four HTTP calls, if you would rather not

    The same thing from any language: ask for an upload, send the bytes to the URL you get back, close the upload, publish once it has passed validation.

    POST /datasets/uploads
PUT  <presigned upload URL>
POST /datasets/uploads/{id}/complete
POST /datasets/uploads/{id}/publish
    The full reference is at app.tilo.lumina.ooo/docs.

Built for agents

An agent should not need to know what a tile server is. With Tilo, its whole job is to drop the file and pass on the URL it gets back.

  • Serve what it produces

    An agent that computes a map, a model output or a cleaned dataset publishes it with the same calls as anyone else and gets back STAC and OGC API URLs it can cite. No bucket, no server, no DNS, no certificate, no scaling to think about.

    GET /collections/{id}
# the collection it just published:
# links to items, tiles and assets
    Links are the contract: an agent follows them instead of guessing URLs.

  • Find what already exists

    Tilo's MCP server lets Claude and other agents search the catalogue in plain language, then hand back the collection, its extent and a small extract to work with.

    POST https://api.tilo.lumina.ooo/mcp
    Discovery only: data still flows through the metered API.

  • A key per agent, revocable on its own

    Give each agent or pipeline its own API key. Revoke one without touching the others; every read is metered and logged against your account.

    POST /api-keys
    Or from the console's settings page.

For research

Publish data the way you publish a result: versioned, addressable, and readable with the tools your field already uses.

  • Versions that never change under an analysis

    A new release never overwrites the previous one. Each published version keeps its own identifier, so a paper, a notebook or a figure can point at exactly the data it used.

    GET /collections/{id}/items
    Each published version is an item of its collection.

  • Open it from a notebook

    The catalogue is standard STAC and OGC API. pystac-client searches it by date and area; rasterio and GDAL read the Cloud-Optimized GeoTIFFs with range requests, without downloading whole files.

    from pystac_client import Client
cat = Client.open(
    "https://api.tilo.lumina.ooo",
    headers={"X-API-Key": KEY})
    Any STAC client works the same way.

  • Share it with reviewers and funders

    Send a link scoped to one collection to people who have no account. It expires on the date you set, up to 30 days, can be revoked at any time, and every read is logged.

    POST /datasets/{name}/shares
    Or one click from the collection's page in the console.

Also

Each one is a request you can make today.

  • Follow a place over time

    Satellite scenes, sensor campaigns or drone flights accumulate in one collection. Filter by date and by area on the server, and compare two acquisitions without downloading either.

    GET /collections/{id}/items
    ?datetime=2026-07-01/2026-07-31
    &bbox=2.25,48.81,2.42,48.90
    Standard STAC search, filtered on the server.

  • Open a whole series in GIS

    One virtual raster for a series of acquisitions, readable by GDAL and QGIS from a single URL.

    GET /collections/{id}/mosaic.vrt
    The latest acquisition by default; the others are listed as sub-datasets.

  • Put maps in your own product

    Serve vector and raster tiles to OpenLayers, MapLibre or any tile client, and query features by bounding box. API keys, rate limits and usage metering are built in.

    GET /collections/{id}/tiles/
    WebMercatorQuad/{z}/{y}/{x}
    OGC API Tiles, on the grid every web map already uses.

Who it's for

Anyone whose work ends in geospatial data someone else has to open.

Research teams and labs
Publish datasets that colleagues, reviewers and funders open from QGIS or a notebook, with versions that never change under an analysis.
Builders of AI agents and pipelines
Let an agent publish what it produces and find what already exists, through one API, without giving it infrastructure to run.
GIS and product teams
Proptech, insurance, local authorities: standard map and feature APIs for your data, without running PostGIS, a tile server and a pipeline yourself.
Survey, engineering and monitoring firms
Deliver each campaign, satellite, sensor or drone, as a live layer instead of a folder of files, and stop answering "which file is the latest?".

Specifications

What Tilo implements, and nothing it does not.

StandardsSTAC API 1.0, OGC API Features Part 1, OGC API Tiles Part 1, TileMatrixSet WebMercatorQuad
Formats inGeoJSON, CSV (points), Shapefile, GeoPackage, GML, KML, GeoTIFF
Formats outVector tiles (PMTiles), Cloud-Optimized GeoTIFF, GeoJSON features, VRT mosaics
Opens inQGIS, ArcGIS, GDAL, rasterio, pystac-client, OpenLayers, MapLibre
ClientsConsole, tilo CLI, Go SDK, MCP server: all built on the public OpenAPI-documented API, like your own code
AccessNothing is anonymous: API keys or session tokens, two-factor sign-in, scoped share links that expire and can be revoked
HostingScaleway, Paris region. Your data stays in the EU. Enterprise plans run on dedicated infrastructure under their own subdomain.

Start with a free account

It is enough to preview the whole shared catalogue and to publish one private dataset of up to 1 GB. Upgrade from the console when you need more.

Create a free account Open the console