Build on Monitor.Guide: APIs and Developer Platform

Most intelligence platforms are walled gardens. You pay for access, you use their interface, and if you want to build something custom, you’re out of luck. The data is locked behind a UI.

Monitor.Guide is designed differently. The entire intelligence platform, every data feed, every scoring algorithm, every aggregation pipeline, is built on a typed API layer that developers can use, extend, and build upon.

Proto-First Architecture

Monitor.Guide uses Protocol Buffers (protobuf) as the single source of truth for all API contracts. The codebase contains:

• 270 proto files defining every data structure and service
• 34 typed service domains covering all intelligence verticals
• Auto-generated TypeScript clients for type-safe API consumption
• Auto-generated OpenAPI documentation for REST compatibility

This means every API endpoint has:

1. A proto definition that specifies exact request/response types
2. An auto-generated TypeScript client with full type safety
3. An OpenAPI spec for language-agnostic access
4. Runtime validation that rejects malformed requests

Why Proto-First Matters

Protocol Buffers enforce a contract between client and server that can’t drift:

• Type safety: No more guessing what fields an API returns. The proto file is the contract.
• Versioning: Proto files support backward-compatible evolution. Add fields without breaking clients.
• Code generation: TypeScript clients are generated, not handwritten. Zero chance of client/server mismatch.
• Documentation: The proto file IS the documentation. Field names, types, and comments are the API spec.

For developers building on Monitor.Guide, this means you can trust the API contracts completely. If the proto says a field is int64, it’s int64. If it says repeated string, it’s an array of strings.

34 Service Domains

Monitor.Guide’s API is organized into domain-specific services:

Each domain has its own edge function, proto definitions, and TypeScript client.

60+ Vercel Edge Functions

The API layer runs on Vercel Edge Functions, providing:

• Global edge deployment: API responses from the nearest edge node
• ~85% cold-start reduction through per-domain thin entry points
• Circuit breakers per data source (failing upstream won’t take down the API)
• Cache-Control headers with ETag support for efficient CDN caching
• Rate limiting with Cloudflare-aware client IP detection

API endpoints follow the pattern:

monitor.guide/api/{domain}/v1/{rpc}

For example:

• monitor.guide/api/market/v1/quotes for stock quotes
• monitor.guide/api/conflict/v1/events for conflict data
• monitor.guide/api/intelligence/v1/cii for Country Instability Index scores

Building with Monitor.Guide’s API

Custom Dashboards

Build a domain-specific dashboard that pulls exactly the data you need. Use the typed TypeScript clients for a smooth development experience:

// Auto-generated client with full type safety
const cii = await intelligenceClient.getCII({ countries: ['US', 'CN', 'RU'] });
// cii.scores is typed as CIIScore[] with all fields known at compile time

Data Pipelines

Feed Monitor.Guide data into your own analytics:

• Pull conflict events into a data warehouse for historical analysis
• Stream market data alongside geopolitical scores for correlation studies
• Build custom alerting on CII threshold changes

Research Applications

Academic researchers can use the API programmatically:

• Study the relationship between news velocity and conflict escalation
• Analyze prediction market accuracy against actual outcomes (see prediction markets and AI forecasting)
• Build custom scoring models using Monitor.Guide’s raw data feeds

Mobile Apps

Build a mobile app that consumes Monitor.Guide’s API for a custom mobile intelligence experience. The OpenAPI spec makes it accessible from any language (Swift, Kotlin, Python, Go).

Slack/Teams Bots

Build alerting bots that post to your team channel when:

• A country’s CII crosses a threshold
• A strategic theater posture changes
• A prediction market probability shifts significantly
• A cyber threat spike is detected in your region of interest

Self-Hosting

Monitor.Guide is AGPL-3.0. You can self-host the entire platform, including local AI capabilities that run without cloud dependencies:

Frontend: React + TypeScript + Vite. Standard npm install && npm run build.

API: Vercel Edge Functions. Deploy to Vercel with vercel deploy, or adapt for Cloudflare Workers, Deno Deploy, or any edge runtime.

Desktop App: Tauri. Build with cargo tauri build for macOS, Windows, or Linux.

Data Layer: Redis for caching, with seed scripts that populate data from public sources.

Self-hosting gives you:

• Complete control over data flows
• Custom domain deployment
• Network isolation for sensitive environments
• Ability to add proprietary data sources

Contributing

The open-source codebase welcomes contributions:

• New data sources: Add proto definitions, implement handlers, wire into the seed pipeline
• New languages: Add translation JSON files for additional locale support
• Bug fixes: Standard GitHub PR workflow
• New panels: Build new visualization panels using the typed data layer
• Performance: Edge function optimization, caching improvements, bundle size reduction

The proto-first architecture makes contributing safe: the type system catches contract violations at compile time, and auto-generated clients ensure frontend/backend consistency.

The Developer Stack

For reference, Monitor.Guide is built with:

Why Build on Monitor.Guide?

The intelligence industry has a consolidation problem. A handful of vendors control the data, the algorithms, and the interfaces. Analysts are locked into ecosystems they can’t customize, audit, or extend. See how Monitor.Guide compares to traditional intelligence tools in practice.

Monitor.Guide’s open, typed, proto-first architecture is the alternative:

• Audit everything: Every scoring algorithm, every data pipeline, every API contract is in the codebase
• Extend anything: Add data sources, build custom panels, create new service domains
• Trust the types: Proto-generated clients mean no runtime surprises
• Deploy anywhere: Edge functions, self-hosted, or desktop
• Own your intelligence: No vendor lock-in, no API key revocation, no price hikes

The intelligence platform of the future isn’t a product. It’s an ecosystem. Monitor.Guide is building the foundation.

Building an AI agent instead of an app? The same platform is exposed as a Model Context Protocol server with 39 live tools. See how to connect Claude and other agents to Monitor.Guide’s MCP server.

Frequently Asked Questions

Is the Monitor.Guide API free to use? Yes. Monitor.Guide is AGPL-3.0 open source. You can use the public API at monitor.guide/api or self-host the entire stack. There are no API keys required for public endpoints and no usage fees.

What languages can I use to consume the API? Any language that supports HTTP. The auto-generated OpenAPI spec provides compatibility with Swift, Kotlin, Python, Go, Java, and more. TypeScript clients are generated directly from the proto files for first-class type safety.

How do I add a custom data source to my self-hosted instance? Define your data structures in a proto file, implement a handler function, wire it into the service registry, and add a seed script to populate Redis. The proto-first architecture ensures type safety across the full stack automatically.

Start building at github.com/LookNoHandsMom/Monitor.Guide. 34 services, 270 proto files, and a global intelligence dataset waiting for your application.