Lynker Spatial Tile Service - Complete Documentation

Welcome to Lynker Spatial Tiles

Access geospatial tile data for watershed analysis, flood modeling, land cover classification, and more.

Get Started Now

Service Overview

The Lynker Spatial Tile Service provides cloud-hosted vector and raster tile datasets optimized for web and desktop applications. All data is served in Protocol Buffer (PBF) format with JWT Bearer token authentication.

Service Base URL: https://tiles.lynker-spatial.com

Available Datasets

Hydrofabric Nexus: Watershed divides, flowlines, and routing networks
PADUS: Protected Areas Database of the United States
Wetlands: National Wetland Inventory data
Flowline Features: Stream classification and geometry
Reservoirs: Dam and reservoir locations and characteristics
Earth Observation: Flooding, land cover, and hazard analysis

Key Features

Vector tiles in PMTiles/MVT format for efficient delivery
Zoom level support from 0 to 28 for detailed mapping
JWT Bearer token authentication for secure access
Monthly data quota per token (5 GB) with production request throttling handled by CDN/API layer
RESTful API with catalog discovery
Support for all major Web GIS platforms
Low-latency delivery via AWS CloudFront CDN

Getting Started

Start in 5 Minutes (Recommended)

Use this exact endpoint and layer as your default first integration target.

# 1) Verify token + service
curl -H "Authorization: Bearer YOUR_TOKEN" \
    https://tiles.lynker-spatial.com/catalog

# 2) Pull one known tile from modeling fabric
curl -H "Authorization: Bearer YOUR_TOKEN" \
    https://tiles.lynker-spatial.com/api/tiles/lynker-spatial-modeling-fabric/5/9/11 \
    -o tile.pbf

# 3) MapLibre defaults
tiles: ['https://tiles.lynker-spatial.com/api/tiles/lynker-spatial-modeling-fabric/{z}/{x}/{y}']
'source-layer': 'flowpath'
                        

The Lynker Spatial Tile Service consists of:

Base URL: https://tiles.lynker-spatial.com
Tile Format: PBF (Protocol Buffers) / PMTiles
Authentication: JWT Bearer Token (expires per Cognito app client; this deployment uses 1 day)
Default Projection: Web Mercator (EPSG:3857)
Tile Naming: {source}/{z}/{x}/{y} (omit .pbf extension)

Quick Start: Five Steps

Quick Setup Checklist

Go to https://proxy.lynker-spatial.com/ to sign up or sign in

Verify your email (if new account)

Visit https://proxy.lynker-spatial.com/token to see your JWT token

Copy your token for authentication

Test access (catalog is public):

curl -i https://tiles.lynker-spatial.com/catalog

# Optional: you may include Authorization but it's not required for catalog discovery
curl -i -H "Authorization: Bearer TOKEN" https://tiles.lynker-spatial.com/catalog
                

System Requirements

Internet Connection: HTTPS connections required
HTTP/2 Support: Recommended for efficient tile streaming
TLS 1.2+: For secure authentication
Standard GIS Software: Works with MapLibre, QGIS, ArcGIS, Leaflet, etc.

Sign Up & Account Setup

📧 Step 1: Create or Sign In

Visit the Lynker Spatial authentication portal to create an account or sign in.

Go to Portal

✓ Step 2: Verify Email

Check your email inbox for a verification link and confirm your account (if new).

🔑 Step 3: Get Your Token

Visit https://proxy.lynker-spatial.com/token to view your access token.

🚀 Step 4: Start Using Tiles

Use your token in the Authorization header to access all tile endpoints.

Token Management

Your JWT token is available at https://proxy.lynker-spatial.com/token after signing in:

View your current access token
Token expiry varies by Cognito app client. This deployment uses 1 day access/ID tokens and 30 day refresh tokens; clients should read the token's `expires_in` and refresh a few minutes before expiry.
Use in Authorization header: Bearer <token>
Refresh tokens automatically when they expire
Tokens are user-specific, not organization-wide

Authentication & Authorization

All requests to the Lynker Spatial Tile Service require JWT Bearer token authentication. Tokens are issued through AWS Cognito; token lifetimes vary by Cognito app client. This deployment uses 1 day access/ID tokens and 30 day refresh tokens — configure your client to refresh tokens proactively based on the returned `expires_in`.

Getting Your Token

Recommended: Visit the web portal to view and copy your token:

https://proxy.lynker-spatial.com/token

Your token is a JWT that expires according to your Cognito app client's configuration. In this deployment the app client issues 1 day access/ID tokens; for production applications, read the token's `expires_in` and implement refresh logic a few minutes before expiry.

Using Your Token

Include the token in the Authorization header for all tile service requests:

curl -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
    https://tiles.lynker-spatial.com/api/tiles/lynker-spatial-modeling-fabric/5/9/11
            

Security Note: Tokens expire every hour. Implement token refresh logic in production applications. Never commit tokens to version control.

Token Refresh Pattern

Implement automatic token refresh to handle expiration:

// Example: Node.js token refresh
async function getValidToken() {
  const cached = getCachedToken();
  if (cached && !isExpired(cached)) {
    return cached;
  }
  
  const newToken = await requestNewToken();
  cacheToken(newToken);
  return newToken;
}

// Use in requests
const token = await getValidToken();
// For catalog discovery the Authorization header is optional; include it when available
fetch('https://tiles.lynker-spatial.com/catalog', {
    headers: token ? { 'Authorization': `Bearer ${token}` } : {}
});
            

Testing Authentication

Verify your setup works:

# Test 1: Get service catalog (requires valid token)
curl -H "Authorization: Bearer YOUR_TOKEN" \
  https://tiles.lynker-spatial.com/catalog

# Test 2: Request a specific tile (note: no .pbf extension in URL)
curl -H "Authorization: Bearer YOUR_TOKEN" \
    https://tiles.lynker-spatial.com/api/tiles/lynker-spatial-modeling-fabric/5/9/11 \
  -o tile.pbf

# Verify the file is valid
file tile.pbf
# Should output: tile.pbf: Protocol Buffer data
            

Authorization Scopes

Token permissions are controlled through scopes:

tiles:read - Read access to tile data (default)
tiles:admin - Administrative access (rarely needed)
organization:manage - Manage organization settings

MapLibre GL JS Integration

MapLibre GL JS is a free, open-source JavaScript library for interactive maps. It provides excellent support for vector tiles and is ideal for web applications.

Installation

# Via npm
npm install maplibre-gl

# Via CDN (for simple projects)
<script src='https://unpkg.com/maplibre-gl@latest/dist/maplibre-gl.js'></script>
<link href='https://unpkg.com/maplibre-gl@latest/dist/maplibre-gl.css' rel='stylesheet' />
            

Basic Map with Tiles

<!DOCTYPE html>
<html>
<head>
  <meta charset='utf-8' />
  <title>Lynker Tiles with MapLibre</title>
  <meta name='viewport' content='initial-scale=1,maximum-scale=1,user-scalable=no' />
  <script src='https://unpkg.com/maplibre-gl@latest/dist/maplibre-gl.js'></script>
  <link href='https://unpkg.com/maplibre-gl@latest/dist/maplibre-gl.css' rel='stylesheet' />
  <style>
    body { margin: 0; padding: 0; }
    #map { position: absolute; top: 0; bottom: 0; width: 100%; }
  </style>
</head>
<body>
<div id='map'></div>

<script>
const map = new maplibregl.Map({
  container: 'map',
  style: 'https://demotiles.maplibre.org/style.json',
  center: [-100, 40],
  zoom: 6
});

map.on('load', () => {
    // Add modeling fabric flowpaths layer
  map.addSource('padus', {
    type: 'vector',
        tiles: ['https://tiles.lynker-spatial.com/api/tiles/lynker-spatial-modeling-fabric/{z}/{x}/{y}'],  // omit .pbf extension
    minzoom: 0,
    maxzoom: 14
  });
  
  map.addLayer({
    id: 'padus-fill',
    type: 'fill',
    source: 'padus',
    'source-layer': 'flowpath',
    paint: {
      'fill-color': '#088',
      'fill-opacity': 0.3
    }
  });
  
  map.addLayer({
    id: 'padus-outline',
    type: 'line',
    source: 'padus',
    'source-layer': 'flowpath',
    paint: {
      'line-color': '#088',
      'line-width': 2
    }
  });
});
</script>
</body>
</html>
            

Authentication in MapLibre

Since MapLibre runs in the browser, handle authentication through a proxy server:

// Option 1: Proxy tile requests through your backend
const tileUrl = '/api/proxy/tiles/{z}/{x}/{y}';

map.addSource('padus', {
  type: 'vector',
  tiles: [tileUrl],
  minzoom: 0,
  maxzoom: 14
});

// Your backend proxy adds the Authorization header
// Example Express.js proxy:
app.get('/api/proxy/tiles/:z/:x/:y', (req, res) => {
    const tileUrl = `https://tiles.lynker-spatial.com/api/tiles/lynker-spatial-modeling-fabric/${req.params.z}/${req.params.x}/${req.params.y}`;
  
  fetch(tileUrl, {
    headers: { 'Authorization': `Bearer ${process.env.LYNKER_TOKEN}` }
  })
    .then(r => r.buffer())
    .then(buffer => {
      res.set('Content-Type', 'application/octet-stream');
      res.send(buffer);
    })
    .catch(err => res.status(500).json({ error: err.message }));
});
            

Advanced Styling

Use data-driven styling to create thematic maps:

map.addLayer({
  id: 'padus-styled',
  type: 'fill',
  source: 'padus',
    'source-layer': 'flowpath',
  paint: {
    'fill-color': [
      'interpolate',
      ['linear'],
      ['get', 'protection_level'],
      0, '#fee5d9',
      1, '#fcae91',
      2, '#fb6a4a',
      3, '#cb181d'
    ],
    'fill-opacity': [
      'case',
      ['boolean', ['feature-state', 'hover'], false],
      0.7,
      0.3
    ]
  }
});

// Add hover effects
map.on('mousemove', 'padus-styled', (e) => {
  if (e.features.length > 0) {
    map.setFeatureState(
      { source: 'padus', id: e.features[0].id },
      { hover: true }
    );
  }
});
            

Interactivity

// Click handler for feature information
map.on('click', 'padus-fill', (e) => {
  const properties = e.features[0].properties;
  
  new maplibregl.Popup()
    .setLngLat(e.lngLat)
    .setHTML(`
      <h3>${properties.name}</h3>
      <p>Type: ${properties.type}</p>
      <p>Area: ${properties.area_sqmi} sq mi</p>
    `)
    .addTo(map);
});

// Change cursor on hover
map.on('mouseenter', 'padus-fill', () => {
  map.getCanvas().style.cursor = 'pointer';
});

map.on('mouseleave', 'padus-fill', () => {
  map.getCanvas().style.cursor = '';
});
            

QGIS Integration

QGIS 3.x has native support for vector tiles. Here are three methods to add Lynker Spatial tiles to your QGIS projects.

Method 1: Vector Tile Layer (GUI)

Step-by-Step Instructions

Open QGIS and go to Layer → Add Layer → Add Vector Tile Layer

Click the New button to create a new connection

Enter connection details:

Name: Lynker PADUS
URL: https://tiles.lynker-spatial.com/api/tiles/lynker-spatial-modeling-fabric/{z}/{x}/{y}  (omit .pbf extension)
                    

Go to the HTTP Headers tab

Add custom header:

Header Name: Authorization
Header Value: Bearer YOUR_ACCESS_TOKEN
                    

Click OK and save the connection

Select the connection from the list and add the layer

Configure symbology by right-clicking the layer → Properties → Symbology

Method 2: Python Console

from qgis.core import QgsVectorTileLayer, QgsProject
from qgis.utils import iface

# Create vector tile layer (note: no .pbf extension in URL)
url = 'https://tiles.lynker-spatial.com/api/tiles/lynker-spatial-modeling-fabric/{z}/{x}/{y}'
layer = QgsVectorTileLayer(url, 'PADUS Protected Areas')

# Add to project
QgsProject.instance().addMapLayer(layer)

print(f"Layer added: {layer.name()}")
            

Method 3: Custom Python Plugin

For more control, create a custom plugin:

import requests
from qgis.core import QgsVectorTileLayer, QgsProject

class LynkerTileManager:
    def __init__(self, token=None):
        self.token = token
        self.base_url = 'https://tiles.lynker-spatial.com'
    
    def get_catalog(self):
        """Fetch available tile sources (catalog is public; Authorization optional)"""
        headers = {'Authorization': f'Bearer {self.token}'} if self.token else {}
        response = requests.get(f'{self.base_url}/catalog', headers=headers)
        return response.json()
    
    def add_tile_layer(self, source_name, display_name=None):
        """Add a tile layer to QGIS"""
        if display_name is None:
            display_name = source_name
        
        url = f'{self.base_url}/api/tiles/{source_name}/{{z}}/{{x}}/{{y}}'  # no .pbf extension
        layer = QgsVectorTileLayer(url, display_name)
        QgsProject.instance().addMapLayer(layer)
        return layer

# Usage
manager = LynkerTileManager('YOUR_TOKEN')
manager.add_tile_layer('padus', 'Protected Areas')
manager.add_tile_layer('wetlands', 'Wetlands')
            

Styling Vector Tiles in QGIS

Right-click the layer → Properties
Go to the Symbology tab
Select Vector Tile Rendering style
Configure colors, opacity, and outlines for each feature type
Use Rule-based rendering for conditional styling

Troubleshooting

No tiles appearing: Check Authorization header is correct, verify token hasn't expired
Layer visible at all zoom levels: Check minzoom/maxzoom settings in layer properties
Styling issues: Ensure layer names in symbology match actual feature types in tileset

ArcGIS Integration

Add Lynker Spatial tiles to ArcGIS Pro, ArcGIS Online, and ArcMap using multiple connection methods.

ArcGIS Pro Setup

Adding a Vector Tile Service

In ArcGIS Pro, go to Insert → Connections → New Vector Tile Service Connection

Enter the service URL and configure authentication

Add the connection to your project

Drag the connection into your map to add layers

ArcGIS Online

In ArcGIS Online Map Viewer:

Click "Add" → "Add Layer from Web"
Select "Vector Tile Service"
URL: https://tiles.lynker-spatial.com/api/tiles/lynker-spatial-modeling-fabric/{z}/{x}/{y}
Add Authorization header: Bearer YOUR_TOKEN

layer = mapping.Layer(layer_file) mapping.AddLayerToGroup(df, df.listLayers()[0].longName, layer) mapping.RefreshActiveView()

WMS/WMTS Alternative

If vector tiles don't work, use the WMS endpoint:

# In ArcGIS Pro or Online
Add WMS Layer

Service URL:
https://tiles.lynker-spatial.com/wms

Authentication Header:
Authorization: Bearer YOUR_ACCESS_TOKEN

Available Layers:
- padus (Protected Areas)
- wetlands (Wetlands)
- hydrofabric (Hydrofabric)
            

Configuring Proxy for Enterprise

For enterprise deployments, configure a proxy server:

# proxy.ashx or similar proxy configuration
# Note: Use Bearer token in Authorization header instead of ClientId/Secret

QueryableLayerIds: 0,1,2,3,4,5
LogFile: C:\logs\proxy.log
LogLevel: All
ServerUrl: https://tiles.lynker-spatial.com
AllowedReferrers: yourdomain.com
AllowedPorts: 443
HasToken: true
# Get this token from https://proxy.lynker-spatial.com/token
BearerToken: YOUR_JWT_TOKEN_FROM_PORTAL
            

Aspect	Leaflet	MapLibre GL JS
Bundle Size	~39 KB gzipped	~70 KB gzipped
Learning Curve	Easy	Moderate
3D Support	No	Yes
Vector Tile Support	Basic (via proxy)	Native & Advanced
Best Use Case	Simple web maps	Complex styling & effects

OAuth2 Authentication Setup

For production tile access with secure authentication, Lynker Spatial provides an OAuth2-enabled tile proxy. This allows browsers and desktop applications to authenticate once and access tiles without manual token handling.

Why OAuth2?

User-Friendly: Sign in once via browser OAuth flow
Secure: Tokens stored in HttpOnly cookies (not accessible to JavaScript)
Automatic Refresh: Tokens refresh automatically before expiration
No Manual Headers: Authentication handled server-side by the proxy
PKCE Protected: RFC 7636 compliant protection against authorization code interception

Architecture Overview

Browser Application
  ↓
OAuth2 Tile Proxy (https://tiles.lynker-spatial.com)
  • Handles OAuth2 login/logout
  • Manages secure token storage
  • Enforces PKCE authentication
  • Injects tokens into tile requests
  ↓
Upstream Token Service (Cognito, Azure AD, or OIDC provider)
  • Issues & validates JWT tokens
  ↓
Lynker Spatial Tile CDN
  • Serves tiles with verified tokens
            

Quick Start: Browser-Based OAuth2 Flow

1. Check Status: GET /auth/session

2. Login: GET /auth/login?redirectTo=/home (in browser)

3. OAuth Provider: User signs in at OAuth provider

4. Redirect Back: Returns to /home with session cookie

5. Fetch Tiles: Browser now has authentication

6. Logout: POST /auth/logout to clear session

Client-Side Implementation (JavaScript/MapLibre)

const PROXY_URL = 'https://tiles.lynker-spatial.com';

// Check auth status
async function checkAuth() {
  const response = await fetch(`${PROXY_URL}/auth/session`, {
    credentials: 'include'  // Include cookies
  });
  return await response.json();
}

// Login
function login() {
  // Redirect to OAuth provider
  window.location.href = `${PROXY_URL}/auth/login?redirectTo=${encodeURIComponent(window.location.pathname)}`;
}

// Logout
async function logout() {
  await fetch(`${PROXY_URL}/auth/logout`, {
    method: 'POST',
    credentials: 'include'
  });
  // Refresh auth status
  window.location.reload();
}

// Add tiles after authentication
async function initMap() {
  const session = await checkAuth();
  
  if (!session.authenticated) {
    showLoginButton();
    return;
  }
  
  // User is authenticated - add tile layers
  const map = new maplibregl.Map({
    container: 'map',
    style: 'https://demotiles.maplibre.org/style.json',
    center: [-100, 40],
    zoom: 4
  });
  
  map.on('load', () => {
    map.addSource('lynker-tiles', {
      type: 'vector',
      tiles: [`${PROXY_URL}/api/tiles/lynker-spatial-modeling-fabric/{z}/{x}/{y}`],
      minzoom: 0,
      maxzoom: 14
    });
    
    map.addLayer({
      id: 'flowpaths',
      type: 'line',
      source: 'lynker-tiles',
      'source-layer': 'flowpath',
      paint: {
        'line-color': '#0084ff',
        'line-width': 1.5
      }
    });
  });
}

initMap();
            

API Endpoints

Method	Endpoint	Auth Required	Description
GET	/health	❌ No	Service health check
GET	/catalog	❌ No	List all available datasets with metadata
GET	/:dataset	❌ No	Get TileJSON metadata for specific dataset (e.g., /padus, /wetlands)
GET	/auth/session	❌ No	Check authentication status and session info
GET	/auth/login?redirectTo=<path>	❌ No	Start OAuth2 authentication flow (browser)
GET	/auth/callback?code=<code>&state=<state>	❌ No	OAuth provider redirect callback (automatic)
POST	/auth/logout	✅ Yes	Clear session and logout user
GET	/api/tiles/:dataset/:z/:x/:y	✅ Yes	Fetch tile (requires session authentication)

Interactive Example

Try the OAuth2 example in your browser: Open Interactive OAuth2 Example

This example demonstrates:

Real-time authentication status display
OAuth2 login/logout buttons
Automatic tile layer loading after authentication
Session information display

Configuration & Deployment

For detailed setup, configuration, and production deployment instructions, see:

README-OAuth2.md - Complete setup guide
QUICK_REFERENCE.md - API endpoints and quick commands
CURL-EXAMPLES.md - Test scenarios and curl examples
IMPLEMENTATION_SUMMARY.md - Architecture and security details

Security Features

PKCE (RFC 7636): Code challenge/verifier prevents authorization code interception
CSRF Protection: State and nonce validation prevents cross-site attacks
HttpOnly Cookies: Tokens never accessible to JavaScript (prevents XSS)
Automatic Token Refresh: Refreshes tokens before expiration with backoff retry
Token Redaction: Tokens automatically redacted in logs
Secure Session Storage: Redis-ready abstraction for scaling

API Reference

Base URL

https://tiles.lynker-spatial.com

Core Endpoints

GET /catalog

List all available tile sources and metadata

curl -H "Authorization: Bearer YOUR_TOKEN" \
  https://tiles.lynker-spatial.com/catalog

Response (200 OK):
{
  "tiles": {
    "padus": {
      "name": "Protected Areas Database of the US",
      "description": "Federal and state protected lands",
      "minzoom": 0,
      "maxzoom": 14,
      "bounds": [-180, -85.051129, 180, 85.051129],
      "center": [0, 0, 4],
      "attribution": "USDA, USGS, The Nature Conservancy"
    },
    "wetlands": {
      "name": "National Wetland Inventory",
      "description": "Wetlands across the United States",
      "minzoom": 0,
      "maxzoom": 14
    }
  }
}
            

GET /api/tiles/{source}/{z}/{x}/{y}

Retrieve a vector tile

curl -H "Authorization: Bearer YOUR_TOKEN" \
    https://tiles.lynker-spatial.com/api/tiles/lynker-spatial-modeling-fabric/5/9/11 \
  -o tile.pbf

Parameters:
- source: Tile dataset identifier (padus, wetlands, hydrofabric, etc.)
- z: Zoom level (0-14 depending on source)
- x: Tile column index
- y: Tile row index

Response: Binary PBF/MVT data
Status Codes:
- 200: Tile found and returned
- 401: Unauthorized (missing/invalid token)
- 404: Tile not found
- 429: Rate limit exceeded
            

HTTP Headers

Header	Direction	Required	Description
`Authorization`	Request	Yes	Bearer token: `Bearer YOUR_TOKEN`
`User-Agent`	Request	Recommended	Identify your application
`Accept-Encoding`	Request	Recommended	Use `gzip` for compression
`Content-Type`	Response	Yes	`application/octet-stream`
`X-Quota-Remaining-Bytes`	Response	Yes	Remaining bytes in the current monthly token quota
`X-Quota-Total-Bytes`	Response	Yes	Total monthly quota in bytes for the token (e.g. 5368709120 = 5GB)

Rate Limiting

Enforced limits & behavior:

Monthly data quota: 5 GB per token (default: 5368709120 bytes). The service returns X-Quota-Remaining-Bytes and X-Quota-Total-Bytes headers on tile responses.
Request throttling: The application does not enforce a fixed requests-per-minute per token. Request-level throttling and global protections (CDN, API Gateway, WAF) are used in production and may vary by deployment.
Quota enforcement: When a token exceeds its monthly quota the service returns HTTP 429 Too Many Requests. Implement local caching and exponential backoff to avoid hitting quotas.

Error Responses

# 401 Unauthorized
{
  "error": "Unauthorized",
  "message": "Invalid or expired token",
  "status": 401
}

# 404 Not Found
{
  "error": "Not Found",
  "message": "Tile not found at coordinates z/x/y",
  "status": 404
}

# 429 Too Many Requests
{
  "error": "Rate Limited",
  "message": "Too many requests. Retry after 60 seconds.",
  "status": 429,
  "retry_after": 60
}
            

Best Practices for API Calls

Implement connection pooling to reuse HTTP connections
Use HTTP/2 for multiplexing multiple tile requests
Enable gzip compression in Accept-Encoding
Cache tiles locally to reduce API calls
Implement exponential backoff for rate limit retries
Monitor X-Quota-Remaining-Bytes header to avoid hitting quota limits
Set appropriate timeout values (30 seconds recommended)
Include meaningful User-Agent for analytics

Welcome to Lynker Spatial Tiles

Service Overview

Available Datasets

Key Features

Getting Started

Start in 5 Minutes (Recommended)

Quick Start: Five Steps

Quick Setup Checklist

System Requirements

Sign Up & Account Setup

📧 Step 1: Create or Sign In

✓ Step 2: Verify Email

🔑 Step 3: Get Your Token

🚀 Step 4: Start Using Tiles

Token Management

Authentication & Authorization

Getting Your Token

Using Your Token

Token Refresh Pattern

Testing Authentication

Authorization Scopes

MapLibre GL JS Integration

Installation

Basic Map with Tiles

Authentication in MapLibre

Advanced Styling

Interactivity

QGIS Integration

Method 1: Vector Tile Layer (GUI)

Step-by-Step Instructions

Method 2: Python Console

Method 3: Custom Python Plugin

Styling Vector Tiles in QGIS

Troubleshooting

ArcGIS Integration

ArcGIS Pro Setup

Adding a Vector Tile Service

ArcGIS Online

WMS/WMTS Alternative

Configuring Proxy for Enterprise

Leaflet.js Integration

Installation

Basic Map with Tiles

Proxy Setup for Leaflet

Leaflet vs MapLibre Comparison

Folium & Python Jupyter

Installation

Basic Map with Tiles

Working with GeoPandas

Spatial Data Analysis

OpenLayers Integration

Installation

Basic Map Setup

Advanced Styling

R Language Integration

Installation

Basic Map with Leaflet

Working with Spatial Data

Static Maps

Working with Raster Data

OAuth2 Authentication Setup

Why OAuth2?

Architecture Overview

Quick Start: Browser-Based OAuth2 Flow

Client-Side Implementation (JavaScript/MapLibre)

API Endpoints

Interactive Example

Configuration & Deployment

Security Features

Advanced Usage Patterns

Direct HTTP Access

Simple Python Tile Request

API Reference

Base URL

Core Endpoints

GET /catalog

GET /api/tiles/{source}/{z}/{x}/{y}

HTTP Headers

Rate Limiting

Error Responses