Docs

Open source · MIT

Build on the TAKIP platform

TAKIP aggregates aviation, maritime, seismic, conflict, cyber, and OSINT feeds onto a single GPU-rendered map — and exposes every one of them as a plain HTTP endpoint. This is the same API the dashboard runs on. There is no separate, privileged internal tier.

Quick startAPI reference
Endpoints
112
Live feeds
20+
Keys required
0
Guide

Overview

Every data point on the map is rendered through WebGL via MapLibre GL, which is what lets the interface hold thousands of concurrent entities at 60fps. The application is a Next.js app: the map and HUD run in the browser, and each live feed is normalised by a route under /api before it reaches the client.

That boundary is deliberate. Upstream sources disagree about formats, rate limits, and CORS policy, so the API layer absorbs those differences and hands back consistent JSON.

No credentials needed
Aviation, satellites, fires, earthquakes, weather, news, and CVE data all come from public keyless feeds, and the RECON tools run keyless too. A few layers need a key of their own: live vessels, Cloudflare Radar and TomTom traffic flow.
Guide

Quick start

Every feed is a plain GET returning JSON and needs no authentication — paste any of these into a terminal.

curl -s https://takip.dev/api/flights | jq '.commercial_flights | length'

If you only need magnitudes rather than geometry, /api/stats is the right endpoint to poll — it collapses the heavy feeds into a handful of counters.

Aggregate counters
curl -s https://takip.dev/api/stats
# { "stats": { "flights": 9241, "sats": 2043, "cctv": 2117,
#              "weather": 58, "nuclear": 191, "incidents": 412 },
#   "timestamp": "2026-07-29T12:00:00Z" }

The OSINT lookups each take one subject, so they compose cleanly in a pipeline. They need an account, so send an API key:

Passive subdomain enumeration
curl -s -H "Authorization: Bearer $YOUR_API_KEY" "https://takip.dev/api/osint/certs?domain=example.com" | jq -r '.subdomains[]'

The same key opens the accounts API (/api/v1, documented at /api/v1/docs) and replay data (/api/replay). Without one, most of their endpoints answer 401 api_key_required; /api/v1/key-policy lists the ones open to everyone. A free account comes with a key.

Try before you write code
Every GET endpoint in the reference below has a Send request button that runs it against this instance and shows the live response.
Guide

Self-hosting

The map needs Node 20+ and no database. Accounts, and with them the OSINT tools, come from the accounts API in apps/api, which npm run dev starts beside the web app on port 4100. A local instance is three commands:

Local development
git clone https://github.com/batuhantoker/takip.git
cd takip
npm install
npm run dev        # http://localhost:3000

For a production build, or to run the checks:

Build and test
npm run build && npm start
npm run lint
npm test           # vitest
npm run test:live  # includes tests that hit live upstream feeds

A Dockerfile and docker-compose.yml ship with the repository. The container always listens on port 3000 internally; TAKIP_PORT controls the host port it is published on.

Docker
cp .env.example .env
docker compose up -d
Guide

Configuration

Copy .env.example to .env. Read that file before filling anything in — most of the keys it lists are reserved for future sources and are not consumed by the current code.

Read by the application

SDK_INGEST_KEY
Shared secret for /api/sdk/ingest. The endpoint fails closed: while this is unset, ingestion is disabled and returns 503.
AIS_API_KEY
aisstream.io key for live vessel positions. Without it /api/maritime still has ports and chokepoints, but no ships.
CLOUDFLARE_API_TOKEN
A Cloudflare token scoped to Radar: Read, for the internet outages and attack-origins layer. Unset, /api/cloudflare-radar reports itself unconfigured.
TOMTOM_API_KEY
TomTom key for the worldwide traffic flow tiles. Unset, /api/traffic/flow answers 204.
GEMINI_API_KEY_1 … _8
The server’s own Gemini keys for the AI routes, used for Pro plans. Anyone can still send their own in X-Gemini-Key.
TAKIP_PORT
Host port the UI is published on. The container itself always listens on 3000.

Optional — higher limits or deeper results

OPENSKY_CLIENT_ID and OPENSKY_CLIENT_SECRET lift OpenSky’s anonymous budget of 400 credits a day. ETHERSCAN_API_KEY and HELIUS_API_KEY deepen Ethereum and Solana wallet lookups. FIRMS_API_KEY and N2YO_API_KEY are not read: the keyless feeds serve those layers.

Secrets hygiene
Generate secrets with openssl rand -hex 32. Never commit a populated .env — only .env.example belongs in version control.
Guide

Interface guide

The map fills the viewport and every control floats above it. Panels are toggles rather than destinations, so you can build up exactly the picture you need and drop the rest.

Layer Panel
The left rail. Switches individual feeds on and off, and carries the theme selector.
RECON Toolkit
DNS, WHOIS, certificate transparency, IP and ASN enrichment, breach checks, sanctions, CVE lookup, port scanning.
Intel Feed
A running stream of incoming events across every enabled feed.
Region Dossier
Double right-click the map for a composite summary of that location from every feed covering it.
Entity Graph
Link analysis, expanding one node at a time into its neighbours.
Status Bar
Community and docs links on the left, then a live ticker of prices and significant seismic events.
Guide

TI & MCP

TI (Takip AI) is the AI in TAKIP, on your own model key, and it works two ways. Assist is a conversation (press T): ask in words, typed or spoken, and TI works the map for you. It flies to the place you name, switches the layers on, searches what is live (flights, military aircraft, ships, ports and chokepoints, earthquakes, fires, weather, disaster alerts, news, cameras, satellites), marks what it finds in cyan with the area it searched, and lists it in cards you can click through. It reads the markets, opens panels, and starts forecasts. Each step shows what it did as it does it; choose Navigate, Research or Forecast to steer it, or leave it on Auto.

Forecast is TAKIP's prediction engine. Ask it a question and it researches it, builds a world model (the actors, where they are, how they relate), and casts the actors who decide the outcome as agents, each with what it wants, the levers it can pull and its red lines. Then it plays them against each other over simulated time, in dated periods from today to the question's horizon, in several parallel worlds: each period every actor decides its move from what has happened in its world so far, and a world engine turns the moves into dated events, the occasional surprise, and where the question now stands. A report agent then writes the prediction: how it most likely unfolds, date by date, what each actor does, how each world ended, and a calibrated figure with its drivers, scenarios, signposts and dissent. The figure takes the shape the question asks for: a probability for a yes-or-no question, a share for each outcome when it asks which of several will happen, and an estimate with an 80% range when it asks how much. While it runs, it draws itself on the globe as arcs through the sky; every arc and point can be clicked to open exactly that piece of the research, and the camera follows the run until you take it.

Your own key
OpenAI, Anthropic, Google Gemini, OpenRouter, Groq, DeepSeek, xAI, Mistral or Qwen. The key stays in your browser and travels in a header with your requests; the server uses it for your run and never stores or logs it.
Cost
Quick: 4 actors × 3 periods × 2 worlds, about 34 model calls. Standard: 6 × 4 × 3, about 88. Deep: 7 × 4 × 4, about 132. A world that settles early stops spending. Billed by your provider at its own rates.
Sharing
Every run has a link, /?ai=<id>, that replays the whole analysis on the globe for anyone who opens it. Runs are kept for three hours after they finish.
Steering
Whoever started a run holds its token: they alone can inject events into it or stop it. Anyone with a key can question the actors and the report agent.
On the globe
Violet arcs are alignments and cooperation, magenta are rivalries and pressure, indigo is everything in between; evidence from the feeds is a paler wash of its tone, and each move is an arc from the actor that made it to the actor it was aimed at. All three colours are yours to set in the Style Studio (Map layers → TI).
Workspace
Full screen (the expand button, with or without a forecast) opens the TI workspace. On the left, the same Forecast / Assist switch as the panel: the ask form, then the prediction with the report or the execution trace (every step the engine took, timed, with what it produced); or the conversation. In the middle, four views on keys 1 to 4: the live globe; the research graph, after MiroFish, with every actor and cited source and every relation, move and quote between them, filters and a flow layout; the timeline, each simulated world period by period with its events, under the worlds pooled; and sortable tables of actors, moves, events, sources and links. On the right, once there is a run, whatever is selected, as an object with its properties and links. Ctrl+K (⌘K) finds any object by name, and in Assist TI can open the workspace, switch its view and open objects for you.
Research
Before the world model, TI researches the question from sources that can be checked: the reporting (a newsroom of publishers’ own feeds by desk, Yahoo Finance’s newswire for any ticker in play, GDELT and Wikipedia’s Current events, each story with its link and, where the publisher serves it, what the article says; social networks are left out), two years of daily prices for any market price the question turns on, what Polymarket and Manifold price the same question at, Wikipedia background, and the TAKIP feeds where they are on topic. The actors are the real ones the question turns on (governments, leaders, companies, groups), each played from its own interests; a market is the world they move, never a player.
Prices
A question about a price (a coin, a share, an index, a commodity, a currency) is priced. The instrument’s own daily moves, average trend removed, are resampled into 4,000 paths to the horizon: the statistical baseline. Each simulated world gets its own course for the price, spread across what can happen; the period’s events push it; and the price settles the question in that world. The worlds’ events are then run through the market’s own paths, so three worlds read as a probability, not a tally of three outcomes.
What it rests on
Every prediction is shown beside what can be checked, on one scale: the statistical baseline, the prediction market on the same question (real money, many traders), the simulation priced, how the worlds ended, and the prediction itself, each a click from its source. The report agent is told to move off a liquid market or the baseline only for reasons it can name.
Every level
When a prediction market prices the question as a ladder (reach $160, $180, $200…, dip to $90, $60… by the same date), TI reads the whole ladder and sets it beside its own curve, the chance of trading at every level, rung by rung: where the model sees more upside or downside than the crowd, and where they part most.
Its record
The statistical baseline is scored on the instrument’s own past: on days through five years of prices it forecasts, from the year before each day only, whether the price would trade at levels above and below within the question’s span, against what then happened. A calibration chart shows what it said against how often it happened, with its calibration gap and its Brier score beside hindsight.
Sources
The actors back their moves with quotes from numbered sources: the research’s articles and background, items of the live feed, or passages the world model lifts word for word from your own data. Each quote says which way it pushed the actor and why, and links to where it was published; the report shows the evidence that moved the actors, source by source. Each quote is checked against its source and marked verbatim or paraphrase; an actor’s first move that quotes nothing is sent back once. In the research graph every quote is a dotted thread from the actor to its source, and the report joins at the end with a thread to each source its drivers rest on, so any conclusion can be followed back to the words it came from.
Answers
Every run says what kind it is (binary, choice or number) and gives its answer in words, e.g. "62% YES", "Hold (55%)" or "86.4 USD per barrel (80–92)", alongside the figures.

From code, start a run, then follow it over Server-Sent Events or wait for it:

Predict over the REST API
# Start: answers 202 with the run id, a watch link and a run token
curl -s -X POST https://takip.dev/api/ai/runs \
  -H "Content-Type: application/json" \
  -H "X-AI-Provider: openai" \
  -H "X-AI-Key: $OPENAI_API_KEY" \
  -d '{"question": "Will the Fed cut rates at its next meeting?", "depth": "quick"}'

# Wait up to 55 s for the prediction (repeat until status is "done")
curl -s "https://takip.dev/api/ai/runs/RUN_ID?wait=55"

# Or watch it happen
curl -N https://takip.dev/api/ai/runs/RUN_ID/events

The same engine is an MCP server at https://takip.dev/api/mcp (Streamable HTTP). Give an agent the tools ai_predict, ai_get_run, ai_ask, ai_inject, ai_cancel and ai_info, plus takip_world_brief and takip_markets and takip_trending, which are free and need no key. The model key is set once on the connection, as headers, so it never appears in the agent's conversation.

# ~/.hermes/config.yaml
mcp_servers:
  takip:
    url: "https://takip.dev/api/mcp"
    headers:
      X-AI-Provider: "anthropic"
      X-AI-Key: "sk-ant-..."
      X-AI-Model: "claude-haiku-4-5-20251001"
    timeout: 300
How long a prediction takes
A few minutes, depending on depth and provider. ai_predict waits for it when the client accepts a streamed response, sending progress as each phase and period completes. Over plain JSON it waits about 80 seconds, then returns the run id to poll with ai_get_run and wait_seconds.

The method follows MiroFish, the open-source swarm-intelligence engine: seed a parallel world from real material, populate it with agents, let them interact while you inject variables, then hand the simulation to a report agent. TAKIP rebuilds that method natively for its own feeds and globe; no MiroFish code is used. A simulation, not a guarantee.

Guide

Keyboard shortcuts

Press ? at any time inside the application to bring up this list.

FToggle fullscreen
SShare current view
LToggle layer panel
MToggle markets panel
IToggle intel feed
RReset to global view
?Show help
ESCClose panels / popups

In these docs, ⌘K (or /) opens search from anywhere on the page.

API reference

Conventions

All routes live under /api on whatever origin serves the application. Reads are GET, writes are POST with a JSON body. Nothing requires authentication except /api/sdk/ingest, /api/github-webhook, and the AI endpoints when they run on the server's Gemini key, which is for Pro plans. TI runs on a model key you bring, sent in the X-AI-Key header; Authorization is reserved for TAKIP API keys.

Errors
Failures return a non-2xx status with an `error` key, often alongside `detail` carrying the upstream message. Most routes proxy third parties, so treat upstream failure as normal — check response.ok before reading the body.
Caching
Routes set their own Cache-Control TTLs: typically 45–60s for fast-moving feeds, up to a day for static reference data. Polling faster than the TTL gains nothing but load. Where a route advertises refreshInterval, use it.
Rate limits
The three AI endpoints allow 5 requests per minute per IP and return 429 beyond that. Other routes are bounded indirectly by their upstream sources.
Timestamps
Every timestamp field is ISO 8601 in UTC.
Responsible use
The RECON scanner and /api/osint/sweep generate traffic against the targets you name. Only point them at infrastructure you own or have written authorisation to test. The remaining OSINT routes are passive and query third-party datasets rather than the subject itself.
API reference

System status

Liveness and aggregate counters. Safe to poll from monitoring. The accounts API behind /api/v1 (keys, usage, workspaces, ArcGIS, the entity graph) documents itself at /api/v1/docs.

API reference

Aviation and space weather

Aircraft, airports, aviation weather, orbital objects, and heliophysics.

API reference

Space

Launches, the spacecraft fleet, the solar system and the Sun, as the space view reads them. All keyless.

API reference

Earth and environment

Seismic, fire, weather, disaster, radiation, health, and orbital-imagery feeds.

API reference

Geopolitical

Conflict zones, frontlines, event streams, air-raid alerts, travel advice, and country-level risk.

API reference

Media and markets

News aggregation, live broadcast streams, and financial instruments.

API reference

Surveillance and infrastructure

Camera networks, fixed infrastructure, reference datasets, and stream and feature proxies.

API reference

Roads, rail and sea

Measured road traffic, live public transport, shipping, chokepoints, and maritime warnings.

API reference

Internet and services

Connectivity outages, attack origins, and the status pages of major vendors.

API reference

Cyber threats

Vulnerability, attack, malware, and on-chain threat telemetry.

API reference

OSINT tools

The lookup tools behind the RECON panel — keyless, with no scanner backend to run. Every route takes a single subject and returns a normalised result, so they compose well in scripts. Each needs an account: call it signed in, or with an API key, whose calls count against its daily quota; without one it answers 401 `sign_in_required`. Limits are per account: 20 breach lookups (leaks, Hudson Rock) an hour, 30 people searches (phone, email, GitHub, username, profile search) an hour, 30 scans an hour (port scan, subnet sweep, vulnerabilities; these, TLS and the username sweep reach the target from TAKIP’s server, so they need a plan with `recon.scan`, Pro, and answer 403 `entitlement_required` otherwise), 30 CVE lookups a minute, and 15 of the other lookups a minute.

API reference

Recon scanners

Active and web-facing probes the web tier runs itself, keylessly. Each needs an account, like the rest of the OSINT toolkit. Port scans and vulnerability checks share the 30-an-hour scan allowance with the subnet sweep; TLS, headers, tech and subdomains count as ordinary lookups. Targets are validated against private and reserved ranges before any connection.

API reference

Entity graph

Link analysis over entities surfaced elsewhere in the platform.

API reference

AI analysis

Gemini-backed correlation over feed data you supply. All three are POST. Analyze and briefing allow 5 requests a minute per IP, overview 20. The server’s own Gemini key is for Pro plans; analyze and briefing run free for anyone on a Gemini key sent in X-Gemini-Key.

API reference

TI, Takip AI (assist and prediction)

TI Assist, a model on your own key that works the map in conversation, and a prediction engine on live TAKIP intelligence: it casts the actors who decide a question, plays them against each other over dated periods in several parallel worlds, and a report agent writes the predicted path with a calibrated figure. Your model key is sent in headers and never stored. Also served as an MCP server at /api/mcp; see TI guide.

API reference

Polybolos SDK

Push entities from an external platform into the Common Operating Picture, and stream the merged picture back out.

API reference

Webhooks

Inbound hooks from external services.

Next →
Quick start