Features

Everything you need for modern geospatial applications — from fast map services to spatial AI.

OGC Standard

Web Map Service (WMS 1.1.1 & 1.3.0)

Full WMS implementation that renders map tiles from your PostGIS vector data. Multi-layer compositing, transparent backgrounds, and configurable output formats.

  • GetCapabilities — Service metadata and layer discovery with ETag caching
  • GetMap — Render map images with multi-layer compositing
  • GetFeatureInfo — Click-to-query features at point locations
  • GetLegendGraphic — Zoom-aware legend images reflecting active rules
PNG WebP JPEG Up to 4096x4096 CQL Filters 
# WMS GetMap request
GET /wms?
  SERVICE=WMS&
  REQUEST=GetMap&
  LAYERS=parcels,roads&
  BBOX=106.7,-6.3,106.9,-6.1&
  WIDTH=512&
  HEIGHT=512&
  FORMAT=image/webp&
  CQL_FILTER=zone='residential'

✓ 512x512 WebP rendered
OGC Standard

Web Feature Service (WFS 2.0)

Query, filter, and edit vector features directly. Full transactional support (WFS-T) with atomic operations, streaming responses for large datasets, and cursor-based pagination.

  • GetFeature — Query features with CQL filtering, BBOX, and pagination
  • DescribeFeatureType — Schema introspection in JSON
  • Transaction — Insert, Update, Delete with atomic rollback
  • Streaming — Chunked transfer for large result sets
WFS-T Cursor Pagination GeoJSON + GML Geometry Validation 
# WFS GetFeature with filtering
GET /wfs?
  SERVICE=WFS&
  REQUEST=GetFeature&
  TYPENAMES=parcels&
  CQL_FILTER=area > 500&
  COUNT=100&
  OUTPUTFORMAT=application/json

# WFS-T: Insert a new feature
POST /wfs
  <Insert>...</Insert>

✓ 100 features returned
Modern Tiles

Mapbox Vector Tiles (MVT)

Serve vector tiles directly from PostGIS for client-side rendering with MapLibre GL JS, Mapbox GL, or OpenLayers. Smaller payloads, crisp rendering at any zoom, and dynamic client-side styling.

  • Direct from PostGIS — ST_AsMVT for efficient tile generation
  • Client-side rendering — Style in the browser with MapLibre GL
  • Adaptive simplification — Geometry simplified per zoom level
  • Attribute selection — Only include needed properties per tile
MapLibre GL Z/X/Y Tiles Protobuf Cacheable 
# MVT tile request
GET /tiles/parcels/14/13358/8185.pbf

# MapLibre GL source config
{
  "type": "vector",
  "tiles": [
    "/tiles/parcels/{z}/{x}/{y}.pbf"
  ]
}

✓ Protobuf tile served
Raster

Raster & COG Serving

Serve raster data via WMS, WCS, and a dedicated tile API directly from Cloud Optimized GeoTIFFs. Point sampling, band statistics, and built-in colormaps — no pre-tiling or raster database required.

  • Tile API — Dedicated raster tile endpoint with PNG/WebP output alongside WMS and WCS access
  • Built-in colormaps — Viridis, Terrain, NDVI, Temperature, Bathymetry, Grayscale, or custom stops
  • Point sampling — Query pixel values at any coordinate via REST
  • Band statistics — Min, max, mean, stddev per band with preview and legend endpoints
COG WMS + WCS Tile API Colormaps Point Sampling 
# Raster tile API
GET /api/v1/raster/elevation/tiles/
  14/13358/8185?colormap=terrain

# Point sampling
GET /api/v1/raster/elevation/point?
  lon=106.85&lat=-6.2
→ { "value": 847.3, "unit": "m" }

# Band statistics
GET /api/v1/raster/elevation/statistics
→ { "min": 0, "max": 3042, "mean": 612 }
Embedded GDAL

Data Import

Import spatial data directly through the web UI or API. Embedded GDAL means no external tools needed — upload your file and it lands in PostGIS, registered and ready to serve.

  • 20+ vector formats — Shapefile, GeoPackage, GeoJSON, KML, GPX, FlatGeobuf, GeoParquet, FileGDB, and more via embedded GDAL
  • Multi-layer detection — Auto-detect layers in complex files with selective import
  • Chunked upload — Resumable uploads for large files with progress tracking via SSE
  • CRS auto-detection — Reads source projection, reprojects to EPSG:4326
Shapefile GeoPackage GeoJSON GeoParquet FlatGeobuf File GDB GeoTIFF / COG MBTiles 
# Upload via REST API
POST /api/v1/import/upload
  Content-Type: multipart/form-data
  file: parcels.gpkg

# Server auto-detects layers
{
  "layers": [
    { "name": "parcels", "features": 12450 },
    { "name": "roads", "features": 3200 }
  ]
}

✓ Imported 15,650 features in 4.2s
JSON Styles

Dynamic Styling

No SLD, no XML. Style your layers with clean JSON. Zoom-dependent properties, rule-based classification, categorized and graduated themes — all with live updates, no server restart needed.

  • Zoom interpolation — Stroke width, opacity, and colors vary by zoom via stops
  • Rule-based classification — CQL conditions map to different styles
  • Label engine — Point, line-following, and polygon labels with collision detection
  • MapLibre expressions — Auto-generate client-side MVT styles from your rules
Categorized Graduated Labels Zoom Stops Live Update 
// JSON style with zoom stops
{
  "rules": [{
    "filter": "zone = 'residential'",
    "fill": {
      "color": "#4ade80",
      "opacity": 0.6
    },
    "stroke": {
      "width": {
        "stops": [[10, 0.5], [16, 2]]
      }
    },
    "label": {
      "field": "name",
      "size": 12
    }
  }]
}
Query Language

CQL Filtering

Filter features across WMS, WFS, and styles using Common Query Language. Attribute comparisons, pattern matching, spatial predicates — all parsed as a safe AST to prevent injection.

  • Comparison operators — =, !=, >, <, >=, <=, LIKE, IN, IS NULL
  • Logical operators — AND, OR, NOT with grouping
  • Spatial predicates — BBOX, INTERSECTS, WITHIN, CONTAINS, CROSSES
  • Safe parsing — AST-based evaluation prevents CQL injection
WMS Filters WFS Filters Style Rules Spatial Queries 
# Attribute filtering
population > 1000000
zone = 'residential' AND area < 500
name LIKE 'North%'
type IN ('primary', 'secondary')

# Spatial filtering
BBOX(106.7, -6.3, 106.9, -6.1)
INTERSECTS(POLYGON((
  106.8 -6.2, 106.9 -6.2,
  106.9 -6.1, 106.8 -6.1,
  106.8 -6.2
)))

# Combined
zone = 'commercial' AND
  BBOX(106.7, -6.3, 106.9, -6.1)
Modern Standard

OGC API

Full implementation of the modern OGC API family — REST/JSON endpoints alongside classic WMS/WFS. Features, Tiles, Coverages, Records, and Processes (Enterprise) with OpenAPI documentation.

  • OGC API – Features — CRUD operations with CQL2-Text/JSON filtering, bbox, datetime, and pagination
  • OGC API – Tiles — Vector and raster tiles with TileMatrixSet metadata
  • OGC API – Coverages — Raster coverage access with band subsetting
  • OGC API – Records — Layer catalog with free-text and spatial search
  • OGC API – Processes — Async job execution mapped to plugin operations (Enterprise)
  • Interactive API Docs — Built-in Swagger UI and Redoc with full OpenAPI 3.0 spec (112 paths, 41 schemas)
Features Tiles Coverages Records Processes Swagger UI 
# OGC API Features — query with CQL2
GET /ogc/collections/parcels/items?
  filter=area > 500&
  bbox=106.7,-6.3,106.9,-6.1&
  limit=50

# OGC API Tiles
GET /ogc/collections/parcels/tiles/
  WebMercatorQuad/14/13358/8185

# Conformance + OpenAPI
GET /ogc/conformance
GET /ogc/api

✓ Full OGC API compliance
Catalog

STAC Catalog

Built-in SpatioTemporal Asset Catalog (STAC v1.1.0) for discovering and searching your raster and vector layers. Cross-collection search with spatial, temporal, and free-text filters.

  • Auto-catalog — All layers automatically exposed as STAC items with bbox and temporal extent
  • Cross-collection search — Search across all collections by bbox, datetime, IDs, or free text
  • STAC API v1.0.0 — Compatible with STAC Browser, PySTAC, and other STAC clients
  • Asset links — Direct links to WMS, WFS, MVT, and COG tile endpoints per item
STAC v1.1.0 Catalog Search Collections Items 
# STAC catalog root
GET /stac/

# Search across collections
POST /stac/search
{
  "bbox": [106.7, -6.3, 106.9, -6.1],
  "datetime": "2024-01-01/..",
  "collections": ["raster"]
}

# Browse collection items
GET /stac/collections/vector/items

✓ Compatible with STAC Browser & PySTAC
Built-in

Authentication & Security

JWT authentication with HTTP-only cookies — immune to XSS token theft. Layer-level permissions, role-based access control, audit logging, and OWASP Top 10 compliance built in from day one.

  • JWT auth — RS256, ES256, HS256 with HTTP-only cookies (no localStorage)
  • Keycloak / OIDC — Enterprise SSO via OpenID Connect with JWKS auto-discovery
  • Layer permissions — View, Edit, Owner levels per user and group
  • Rate limiting — Configurable per-endpoint rate limits (auth, API, tiles, WMS, WFS groups)
JWT Keycloak / OIDC RBAC Rate Limiting Audit Log 
# Layer permission levels
View   → Read-only (WMS, WFS Get)
Edit   → Read + Write (WFS-T)
Owner  → Full control

# Security headers
Strict-Transport-Security
X-Content-Type-Options
X-Frame-Options
Content-Security-Policy

# OWASP compliance
✓ SQL injection: parameterized queries
✓ CQL injection: AST parsing
✓ XSS: HTTP-only cookies
✓ Memory safety: Rust
Performance

Multi-Layer Caching

Automatic tile and query caching with configurable TTLs. Community uses in-memory LRU (moka), Enterprise adds disk, Redis, and Redis Cluster backends. ETags for capabilities, smart cache keys for tiles.

  • Tile cache — Rendered images keyed by layer, BBOX, zoom, style, and CQL filter
  • Query cache — PostGIS feature results cached for repeat queries
  • Capabilities cache — GetCapabilities XML with ETag support
  • Per-layer control — Clear cache per layer or globally via API
Memory (moka) Disk Redis / Cluster ETag 
# Cache hierarchy
Browser Cache (HTTP headers)
  ↓ cache miss
CDN/Proxy Cache
  ↓ cache miss
Tile Cache (moka / Redis)
  ↓ cache miss
Query Cache (feature results)
  ↓ cache miss
PostGIS (spatial index)

# config.toml
[cache.tile]
backend = "memory"
max_entries = 10000
ttl_seconds = 3600
Enterprise

Enterprise Caching Architecture

Three-tier caching for maximum performance at any scale. Scales horizontally with shared caching across nodes.

  • L1 Memory / Redis — sub-millisecond in-process cache or shared Redis / Redis Cluster across all nodes
  • L2 Disk Cache — persistent, LRU eviction, configurable at runtime via Settings UI
  • L3 Render — on full cache miss, render from source and populate L1 + L2
  • Multi-node — a tile rendered by Node 1 is instantly available to all other nodes via shared Redis
Memory (moka) Redis Cluster Disk LRU Zero-config HA

Tile Request

WMS, MVT, COG, OGC API

L1 — Check

Memory

Per-node

Redis

Shared

Miss → L2

Disk Cache

Persistent, node-local

Miss → L3

Render

PostGIS + tiny-skia

Populate L1 + L2
Rust-Powered

Performance & Deployment

No JVM, no Python runtime, no external dependencies to manage. Single binary, sub-second startup, and efficient concurrent request handling via Tokio.

  • Single binary — All dependencies bundled (GDAL, GEOS, PROJ included)
  • Prometheus metrics — Built-in /metrics endpoint for monitoring with Grafana or any scraper
  • Health probes — /health and /ready endpoints for container orchestration
  • Chunked uploads — Large file import with resumable chunked upload and SSE progress
Single Binary Prometheus Health Probes Daemon Mode 
# Supported platforms
Linux   x86_64  glibc 2.28+
macOS   arm64   Apple Silicon
WSL2    x86_64  Windows + WSL

# Just run it
$ ./geovertix serve
✓ WMS available at /wms
✓ WFS available at /wfs
✓ MVT available at /tiles
✓ API available at /api/v1
✓ Server ready

# Or as a daemon
$ ./geovertix serve    # daemonizes
$ ./geovertix stop     # graceful stop
$ ./geovertix restart  # zero-downtime
Enterprise Edition

Plugin Ecosystem

Extend GeoVertix with licensed plugins for geoprocessing, AI, 3D visualization, and more. Each plugin is a separate signed binary managed by the distributed task dispatcher.

Enterprise Plugin

Geoprocessing

Server-side spatial analysis on your PostGIS layers. Buffer, clip, union, intersect, dissolve, and more — all executed as async jobs with progress reporting and output layer registration.

  • Buffer — Create distance-based zones around features
  • Clip & Intersect — Overlay analysis between layers
  • Union & Dissolve — Merge and aggregate geometries
  • Spatial Join — Enrich features based on spatial relationships
  • Centroid & Voronoi — Geometric transformations
PostGIS Native Async Jobs Progress SSE Auto-register Output 
# Buffer a layer by 500 meters
POST /api/v1/process
{
  "operation": "geoprocess.buffer",
  "params": {
    "layer_id": "abc-123",
    "distance": 500,
    "unit": "meters"
  }
}

✓ Job submitted — task_id: "def-456"
✓ Output layer registered as "roads_buffer_500m"
Enterprise Plugin

AI Inference

Serve pre-trained ONNX models for real-time and batch geospatial AI. Pixel classification, object detection, interactive segmentation (SAM), and location embeddings — all from a model registry with hot-reload.

  • Classification — Land use/land cover from Prithvi-EO, Clay, or custom models
  • Detection — Object detection with YOLOv8 (vehicles, buildings, ships)
  • Segmentation — Interactive SAM with point/bbox prompts, encoder caching
  • Embeddings — Location embeddings via SatCLIP with pgvector k-NN search
  • Temporal — Multi-date raster stacking (BTCHW/BCTHW) for change detection
ONNX Runtime Hot-Reload SAM pgvector Ollama / LLM 
# Real-time classification tile
GET /api/v1/inference/tiles/
  lulc-unet/14/13358/8185
  ?layer_id=satellite_rgb

# Interactive SAM segmentation
POST /api/v1/inference/segment
{
  "model": "sam-vit-b",
  "prompts": [
    {"type": "point",
     "x": 106.85, "y": -6.2}
  ]
}

✓ Polygon returned (encoder cached)
Enterprise Plugin

GeoAI Agent

Describe what you want in plain language. The GeoAI agent translates your request into the right spatial operation with the right parameters — no GIS expertise required. Powered by a local LLM (Ollama) for complete data privacy.

  • Natural language dispatch — "Buffer the roads layer by 200 meters and clip it to the city boundary"
  • Multi-step chaining — Automatically sequences operations with output chaining
  • Conversational sessions — Follow-up questions reference previous results
  • Report generation — LLM-written markdown narratives from job results
  • Runs locally — Ollama backend keeps all data on your infrastructure
Local LLM Ollama Multi-Step Chains Data Privacy 
# Chat with GeoAI
User: "Find all buildings within
  200 meters of the river"

GeoAI: I'll run this in 2 steps:
  1. Buffer "rivers" by 200m
  2. Clip "buildings" to the buffer

  [Confirm]  [Cancel]

User: [Confirm]

✓ Step 1/2: Buffer complete
✓ Step 2/2: Clip complete
✓ 1,247 buildings found
Enterprise Plugin

3D Visualization

Full 3D pipeline from import to interactive viewing. IFC (BIM) models get a dedicated Three.js viewer with component browser and can be placed on the map with full transform controls. CityGML becomes 3D Tiles, and point clouds stream as COPC with browser-side LOD.

  • IFC Dedicated Viewer — Three.js scene with OrbitControls, per-node click-to-highlight, opacity control
  • IFC Component Browser — hierarchical tree with search, filter by type/story/material, property inspector
  • Model Placement on Map — place IFC/GLB models at geographic coordinates with full anchor controls (heading, pitch, roll, scale, X/Y offsets)
  • Live Preview — see model on the map in real time as you adjust placement parameters
  • CityGML → 3D Tiles — buildings, terrain, and city models as tiled 3D content via deck.gl Tile3DLayer
  • Point Clouds — LAS/LAZ to COPC with native CRS preservation and progressive 3D Tiles streaming
3D Tiles IFC / BIM CityGML COPC Three.js deck.gl 
# Import IFC model (auto-converts to GLB)
POST /api/v1/process
{
  "operation": "store.import_ifc",
  "params": { "source": "building.ifc" }
}

# Place model on map with transform
PUT /3d/{layer_id}/anchor
{
  "lon": 106.822, "lat": -6.195,
  "heading": 45, "scale": 1.0
}

# Query IFC components
GET /api/v1/layers/{id}/ifc/tree
GET /api/v1/layers/{id}/ifc/components?type=IfcWall

✓ 3D model placed and browsable
Enterprise Plugin

LiDAR / COPC Streaming

Point cloud data stored in COPC format with native CRS preservation. The browser streams tiles via HTTP range requests with LAZ decompression and on-the-fly CRS reprojection for accurate 3D visualization at any scale.

  • Native CRS Storage — COPC files kept in their original coordinate system (not reprojected to EPSG:4326)
  • Browser-side LOD — progressive octree traversal via HTTP range requests, no server-side tile generation
  • LAZ Decompression — point data decompressed in the browser for efficient streaming
  • Color Modes — RGB, elevation, intensity, and classification coloring
  • Classification Filtering — toggle individual point classes on/off
  • CRS Reprojection — PROJ-based reprojection to WGS84 at serve time for map overlay
COPC LAS / LAZ Native CRS HTTP Range 3D Tiles 
# Import point cloud (auto-converts to COPC)
POST /api/v1/process
{
  "operation": "store.import_pointcloud",
  "params": {
    "source": "survey.las",
    "source_srs": "EPSG:32748"
  }
}

# Stream as 3D Tiles (PNTS format)
GET /lidar/{layer_id}/3dtiles/tileset.json
GET /lidar/{layer_id}/info

✓ Point cloud streaming in native CRS
Enterprise Plugin

Terrain Profiles

Serve seismic, ground-penetrating radar (GPR), and sonar profile data as tiled amplitude images with navigation track overlays. Optimized for subsurface exploration and geophysical survey visualization.

  • Seismic / GPR / Sonar — import SEG-Y and similar profile formats
  • Tiled Amplitude Rendering — efficient tile-based serving of large profile datasets
  • Navigation Overlay — survey track lines displayed on the map
  • Vertical Range — configurable depth/amplitude visualization
SEG-Y GPR Seismic Sonar 
# Import seismic profile
POST /api/v1/process
{
  "operation": "store.import_profile",
  "params": {
    "source": "survey_line_01.segy"
  }
}

# Serve profile tiles + navigation
GET /profile/{layer_id}/tiles/{z}/{x}/{y}
GET /profile/{layer_id}/navigation

✓ Profile data ready for visualization
Enterprise Plugin

Climate Analysis

Ingest NetCDF and GRIB climate datasets, compute zonal statistics against vector boundaries, detect anomalies, and analyze trends over time. Results are written back to the spatial database for further analysis and visualization.

  • NetCDF / GRIB Ingestion — standard climate and meteorological data formats
  • Zonal Statistics — aggregate climate variables against polygon boundaries
  • Anomaly Detection — identify deviations from baseline periods
  • Trend Analysis — temporal trends across spatial regions
NetCDF GRIB Zonal Stats Anomalies 
# Run zonal statistics
POST /api/v1/process
{
  "operation": "climate.zonal_stats",
  "params": {
    "climate_layer": "temperature_2025",
    "zones_layer": "districts",
    "variable": "tas"
  }
}

✓ Zonal statistics computed
Enterprise Plugin

MBTiles Tile Serving

Serve raster and vector tiles from collections of sharded MBTiles files. Each collection is a directory of SQLite databases partitioned by zoom-16 grid cells, registered as a raster layer in the database.

  • Sharded Collections — directories of MBTiles files partitioned by grid cell
  • Coverage Grid — visual overlay showing tile availability at low zoom levels
  • In-memory Caching — moka-based tile cache (512 MB default) with SQLite connection pooling
  • Layer Registration — collections registered as raster layers in the database
MBTiles SQLite Tile Cache Coverage Grid 
# List tile collections
GET /mbtiles/collections

# Enable a collection as a map layer
POST /mbtiles/collections/{name}/enable

# Serve tiles directly
GET /mbtiles/{z}/{x}/{y}.png

✓ Tile collection serving
Enterprise Plugin

Object Storage & Data Pipelines

S3-compatible storage with built-in data conversion pipelines. Export layers to S3, import from S3, and convert between spatial formats. Bundled with SeaweedFS for self-hosted object storage.

  • Layer export — GeoJSON, GeoPackage, Shapefile, CSV, KML, DXF to S3
  • Raster export — COG files to S3 buckets
  • Data conversion — LAS→COPC, IFC→GLB, CityGML→3D Tiles, SEG-Y→profiles, OBJ→GLB
  • Self-hosted — bundled SeaweedFS for on-premise S3, no cloud dependency
S3 Compatible SeaweedFS GeoPackage COG Export 
# Export a layer to S3
POST /api/v1/process
{
  "operation": "store.export_layer",
  "params": {
    "layer_id": "abc-123",
    "format": "gpkg",
    "bucket": "exports"
  }
}

✓ parcels.gpkg uploaded to s3://exports/
✓ Download URL generated (24h expiry)
Enterprise Plugin

QGIS Algorithms

Access 220+ QGIS Processing algorithms as server-side operations. The plugin runs QGIS headless inside a container — no desktop installation needed. QGIS native and GDAL processing toolbox available via REST API.

  • 220+ algorithms — QGIS native and GDAL processing tools
  • Containerized — QGIS 3.40 LTR in Docker, managed by the dispatcher
  • Auto-discovery — Operations generated from QGIS algorithm metadata
  • COG output — Raster results converted to Cloud Optimized GeoTIFF
QGIS 3.40 LTR Docker 220+ Algorithms GDAL Tools 
# Run QGIS hillshade algorithm
POST /api/v1/process
{
  "operation": "qgis.native:hillshade",
  "params": {
    "INPUT": "dem_layer",
    "Z_FACTOR": 1.0,
    "AZIMUTH": 315,
    "V_ANGLE": 45
  }
}

✓ Hillshade computed
✓ COG output registered as raster layer

Ready to Get Started?

Download the Community Edition or contact us for Enterprise pricing

Contact Sales