From spatial data to API in three steps

Upload your data

Import CSV, GeoJSON, Shapefile, GeoPackage or GML into PostGIS tables, with options for coordinate reference systems and reprojection.

File import →

Get instant APIs

Query with parameterized SQL over REST or WebSocket and auto-generated GraphQL. Publish layers through OGC API Features & Maps and WMS/WFS.

SQL API →

Build your app

TypeScript SDK with OAuth helpers, realtime subscriptions with server-side filtering, and fine-grained access control.

SDK →

Built for geospatial work, end to end

PostGIS built in

Find nearby features with ST_DWithin, intersect geometries with ST_Intersects, and transform coordinates with spatial SQL.

Explore spatial SQL →

Import your spatial data

Bring GeoJSON, Shapefile, GeoPackage, CSV or GML into your database and expose it through APIs.

Explore data import →

OGC APIs & map services

Read GeoJSON with OGC API Features, render images with OGC API Maps, and connect GIS tools through WMS/WFS. Edit features via WFS-T.

Explore the OGC API →

GraphQL, auto-generated

Queries, mutations and subscriptions derived from your schema.

Realtime over WebSocket

Subscribe to table changes with server-side filtering (shapes).

Control access to your data

OAuth 2.0 (PKCE, password, device flows), sub-users, table-level privileges and SQL rules.

AI-agent ready

Connect AI assistants to inspect schemas, query spatial data and manage your backend through the official MCP server.

Connect AI agents →

Functions for your workflows

Run Node.js or Python code on demand, on a schedule, or in response to events, with access to your data.

Explore functions →

Open source roots

Built on Geocloud2 (AGPLv3) by MapCentia, with 10+ years of geospatial domain expertise.

Explore the open source stack →

Query spatial data. Connect your stack.

Run PostGIS queries over REST or WebSocket, or use the TypeScript SDK with built-in OAuth helpers. Bind values with named parameters such as :lng, :lat and :radius to find nearby features without building your own API server.

Read the SQL API docs →
Build with the TypeScript SDK →

import { PasswordFlow, Sql } from '@centia-io/sdk';

// Sign in once — the SDK stores and refreshes tokens for you
await new PasswordFlow({
  host: 'https://api.centia.io',
  clientId: 'your-client-id',
  username: 'your-username',
  password: process.env.CENTIA_PASSWORD,
  database: 'your-database',
}).signIn();

// Parameterized spatial SQL on PostgreSQL + PostGIS
const { data } = await new Sql().exec({
  q: `select name, st_asgeojson(geom) as location
      from places
      where st_dwithin(geom::geography,
        st_setsrid(st_makepoint(:lng, :lat), 4326)::geography, :radius)`,
  params: { lng: 12.5683, lat: 55.6761, radius: 2000 },
});

{
  "mcpServers": {
    "centia-io": {
      "command": "npx",
      "args": ["-y", "@centia-io/mcp-server"],
      "env": {
        "API_TOKEN": "your-access-token",
        "API_BASE_URL": "https://api.centia.io"
      }
    }
  }
}

-- POST your SQL to /api/v4/sql with named parameters
SELECT
  name, 
  category,
  ST_Distance(
    geom::geography, 
    ST_SetSRID(ST_MakePoint(:lng, :lat), 4326)::geography
  ) AS distance_meters
FROM locations
WHERE ST_DWithin(
  geom::geography,
  ST_SetSRID(ST_MakePoint(:lng, :lat), 4326)::geography,
  :radius
)
ORDER BY distance_meters ASC
LIMIT 10;

# Every layer is served through standard OGC services

# Render a styled map image (WMS GetMap)
https://api.centia.io/api/v4/ows/schema/parks/database/mydb
  ?SERVICE=WMS&VERSION=1.1.0&REQUEST=GetMap
  &LAYERS=parks.areas&SRS=EPSG:3857
  &BBOX=1204164,7485240,1259200,7534200
  &WIDTH=1024&HEIGHT=768&FORMAT=image/png

# Fetch the vector features (WFS GetFeature)
https://api.centia.io/api/v4/wfs/schema/parks/database/mydb
  ?SERVICE=WFS&VERSION=1.1.0&REQUEST=GetFeature
  &TYPENAME=areas&SRSNAME=EPSG:4326

# Works with QGIS, OpenLayers, Leaflet — WFS-T for editing

# Self-host the full stack: app, WebSockets, PostGIS and Redis
git clone https://github.com/centia-io/centia-docker.git
cd centia-docker
docker compose up --build -d

# Connect with the CLI
npm install -g @centia-io/cli
centia connect http://localhost:81
centia login

Open standards: OGC API, WMS & WFS

Browse collections and read GeoJSON through OGC API Features, or render styled map images with OGC API Maps. Filter features by bounding box, page through results and choose a supported coordinate reference system. The OGC API provides read-only REST access to your published layers, with the same privileges and geofence rules as WMS/WFS.

Connect QGIS, OpenLayers, Leaflet and other GIS clients through WMS/WFS, and edit features through WFS-T. Configure map styling with classes, styles and labels through the Layer API.

Read the OGC API Features & Maps docs →
Read the WMS/WFS services docs →
Style layers with the Layer API →

# Read a collection as GeoJSON (OGC API Features)
GET https://api.centia.io/api/v4/ogc/database/mydb/collections/parks.areas/items?limit=10 HTTP/1.1
Accept: application/geo+json
Authorization: Bearer your-access-token

# Render a styled map image (OGC API Maps)
GET https://api.centia.io/api/v4/ogc/database/mydb/collections/parks.areas/map?width=1024&f=png HTTP/1.1
Accept: image/png
Authorization: Bearer your-access-token

What developers build on Centia

Web maps with live data

Realtime layers without building a sync pipeline.

Field data collection

Upload from the field, query from the office.

Open data portals

Publish spatial datasets as queryable APIs.

GIS + AI workflows

Let agents query and manage spatial data via MCP.

Desktop GIS integration

Connect QGIS directly over WMS/WFS and edit with WFS-T.

Location-based applications

Find nearby places, intersect service areas and build spatial queries into your app.

Your geospatial platform. Your choice of deployment.

Managed geospatial BaaS

Build on Centia Cloud

Start with a managed PostGIS backend. Import your data and connect your apps and GIS tools while Centia handles the infrastructure.

Managed PostgreSQL and PostGIS
Data APIs, OGC services and authentication
Free during beta — see limits in the FAQ

Start in Centia Cloud

Geospatial infrastructure

Run it on your infrastructure

Deploy the open source stack with Docker Compose. Keep control of your runtime, networking and data environment, from local development to production.

App, WebSockets, PostGIS and Redis
Your servers and deployment environment
Open source under AGPLv3

Explore self-hosting

Build your next geospatial application

Bring your spatial data. Start with managed cloud or deploy the platform yourself, then connect your maps, apps and GIS tools.

Start in Centia Cloud Explore the docs