Skip to main content
Glama

Open Eagle Eye

npm version License: MIT

MCP server that gives AI agents instant access to public camera feeds worldwide. One HTTP GET, sub-second captures, no browser automation, no stream decoding.

Why

Most camera APIs require authentication, serve video streams, or hide images behind JavaScript rendering. Open Eagle Eye only indexes cameras that return a JPEG or PNG on a plain HTTP GET — the simplest possible integration. Agents don't need to render pages or decode video. They just fetch an image.

The registry is self-healing. A GitHub Action runs nightly, checks every camera, retries failures before removing them, and uses vision AI to catch cameras that return error pages instead of live feeds. Dead cameras get flagged automatically.

Related MCP server: camera-mcp

Quick start

{
  "mcpServers": {
    "openeagleeye": {
      "command": "npx",
      "args": ["-y", "openeagleeye"]
    }
  }
}

Or install globally:

npm install -g openeagleeye
openeagleeye

On first run, the server fetches the latest camera registry from GitHub and caches it locally in ~/.openeagleeye/. Subsequent starts refresh the cache automatically.

How it works

A valid camera URL is any endpoint that returns a JPEG or PNG on a plain HTTP GET. Most city traffic cameras, weather stations, and park cams expose exactly this. The server fetches the image, saves it to disk, and returns the file path.

MCP Tools

Tool

Description

get_snapshot

Fetch a live image from a camera — saves to disk, returns file path

list_cameras

Browse the registry with filters (city, location, category)

search_cameras

Search by name, location, or category

add_local_camera

Add a camera to your local collection

list_local

Show your locally-added cameras

remove_local

Delete a locally-added camera

submit_local

Share local cameras upstream via GitHub issue

report_camera

Report a broken or low-quality camera

check_config

Show API key configuration status

Upstream vs local cameras

The registry has two layers:

  • Upstream — the global registry fetched from GitHub on every server start. These are the ~32,000 validated public cameras.

  • Local — cameras you add yourself via add_local_camera. They persist in ~/.openeagleeye/local-cameras.json, survive restarts, and appear in list_cameras/search_cameras with source: "local". Share them upstream anytime with submit_local.

Filtering

Every camera has a city field. Use list_cameras with city: "Sydney" to get a short, focused list instead of dumping all cameras into context.

Output format

Every tool returns structured JSON. Snapshots save to disk and return the file path — the MCP server runs as a local subprocess, so the agent has filesystem access.

Snapshot response:

{
  "success": true,
  "file_path": "/home/user/.openeagleeye/snapshots/a1b2c3d4e5f6a7b8.jpg",
  "size_bytes": 14579,
  "content_type": "image/jpeg",
  "camera": {
    "id": "nyc-bb-21-north-rdwy-at-above-south-st",
    "name": "BB-21 North Rdwy @ Above South St",
    "city": "New York",
    "location": "Manhattan, New York, USA",
    "coordinates": { "lat": 40.708, "lng": -73.999 }
  }
}

Registry

~32,000 cameras across eleven countries (32,096 verified):

Global Coverage

Country

Count

Sources

US

27,184

NYC DOT, NY 511, WSDOT, Caltrans CWWP2, CDOT CoTrip, VDOT 511, FDOT FL511, NCDOT, PennDOT 511PA, Arizona ADOT, Oregon ODOT, Nevada NDOT, Utah UDOT, Wisconsin WisDOT, New England 511, Louisiana LADOTD, Alaska DOT&PF, Missouri MoDOT

FI

1,309

Digitraffic weather cameras (Fintraffic)

CA

1,292

Ontario MTO, Alberta 511

HK

995

Hong Kong Transport Department

GB

424

London TfL JamCams

NZ

248

NZTA nationwide highways

AU

247

Queensland DOT traffic + flood cameras

BR

160

CET São Paulo urban traffic

JP

98

NEXCO East expressways

SG

90

Singapore LTA

IE

49

TII motorway cams (M50 Dublin)

Every camera has country, city, location, timezone, and coordinates (lat/lng).

Self-healing

A GitHub Action runs nightly at 3 AM UTC:

  • Checks cameras not validated in the last 7 days, plus any flagged as suspect

  • First failure marks as suspect, second consecutive failure removes and opens a GitHub issue

  • Vision AI (GPT-4o-mini via GitHub Models) catches cameras returning error pages

  • Suspect cameras that recover are cleared automatically

Security

  • SSRF protection — blocks private IPs, cloud metadata endpoints, non-HTTP protocols, and DNS rebinding

  • Content-type whitelist — only image/jpeg and image/png accepted

  • Magic byte detection — validates JPEG/PNG by file header when CDN returns wrong content-type

  • Push/PR cap — max 500 cameras per push to prevent DoS via oversized PRs

  • Random filenames — snapshots use random hex filenames, no camera ID in the path

API Keys (optional)

Most cameras work out of the box. Some require a free API key. If a snapshot fails with a key error, the response tells you where to sign up and how to configure it.

Create ~/.openeagleeye/config.json:

{
  "api_keys": {
    "PROVIDER_API_KEY": "your-key-here"
  }
}

Use check_config to see which cameras need keys and whether yours are set.

Adding cameras

  1. Find a direct-image URL (must return image/jpeg or image/png on plain GET)

  2. add_local_camera with the URL, city, location, timezone, and optional coordinates

  3. get_snapshot to test it

  4. submit_local to share upstream — requires the gh CLI (gh auth login)

Local cameras work immediately and don't need upstream approval to be useful.

Good sources: city DOTs, weather stations, ski resorts, national parks, ports, airports.

File layout

All runtime data lives in ~/.openeagleeye/:

~/.openeagleeye/
  cameras.json          # Upstream registry (fetched from GitHub on boot)
  local-cameras.json    # Your locally-added cameras
  .registry-state.json  # Validation state (active/suspect/offline)
  snapshots/            # Downloaded camera images
  config.json           # API keys

Contributing

Pull requests welcome. See CONTRIBUTING.md for guidelines on adding camera sources.

Why this exists

See WHY.md for the reasoning behind the project's design decisions, how it compares to other camera services, and why agent-native and self-healing matter.

Privacy & security

See SECURITY.md for answers to common questions about surveillance, data collection, private cameras, and the security architecture.

License

MIT

Available Tools

13 tools
add_local_cameraA

Add a camera to your local collection. Local cameras persist in ~/.openeagleeye/local-cameras.json and survive restarts and registry updates. They appear in list_cameras and search_cameras with source 'local'. Share upstream anytime with submit_local.

Inputs: name (required), url (required), city (required), location (required), +11 more.

check_configA

Show API key configuration status. Lists all cameras in the registry that require authentication, the provider name, whether a key is configured in ~/.openeagleeye/config.json, and the signup URL for each. Use when a snapshot fails with an API key error to see which keys are missing.

Inputs: no named parameters.

explore_camerasA

Get random cameras from the registry for discovery. Returns a surprise selection. Filter by city, country, or category to narrow the pool, or leave empty for a truly random pick.

Inputs: city, country, category, count.

get_camera_infoA

Look up camera metadata by ID. Returns full details for a single camera without fetching a snapshot. Use this to check if an ID is valid or to get current metadata for a known camera.

Inputs: cam_id (required).

get_snapshotA

Fetch a live image from a camera. Downloads the image to disk and returns the file path. Works on both upstream registry cameras and locally-added cameras. Use list_cameras or search_cameras first to find IDs.

Inputs: cam_id (required).

get_snapshotsA

Fetch live images from multiple cameras in one call. Returns all snapshot file paths. Use to compare several cameras at once or to monitor a set of favorites. Max 5 cameras per call.

Inputs: cam_ids (required).

list_camerasA

Browse the camera registry. Returns cameras with id, name, city, country, location, category, coordinates, and source (upstream or local). Supports filtering by city, country, location, and category. Use limit/offset for pagination — the full registry is large.

Inputs: city, country, location, category, +2 more.

list_localA

Show your locally-added cameras. These persist in ~/.openeagleeye/local-cameras.json and survive restarts and registry updates. They appear in list_cameras and search_cameras with source 'local'. Returns camera IDs, names, URLs, coordinates, and auth requirements.

Inputs: no named parameters.

nearby_camerasA

Find cameras within a geographic radius. Returns cameras sorted by distance from the given point. Use for spatial queries like 'webcams near Times Square' or 'cameras within 10km of the Opera House'.

Inputs: lat (required), lng (required), radius_km, limit, +1 more.

remove_localA

Delete a locally-added camera by ID. Removes it from ~/.openeagleeye/local-cameras.json and the in-memory merged view. The camera is also auto-removed from the merged list. Use after sharing upstream via submit_local, or when a URL stops working.

Inputs: cam_id (required).

report_cameraA

Report a broken or low-quality camera. Files a GitHub issue with a snapshot showing the current state, and saves the report locally. If the camera is local with a broken link, it is automatically removed. Requires 'gh' CLI for GitHub issue creation.

Inputs: cam_id (required), status (required), notes.

search_camerasA

Search cameras by text. Matches against name, city, country, location, and category. Use when looking for cameras in a specific place or of a specific type.

Inputs: query (required), limit.

submit_localA

Share your locally-added cameras with the upstream Open Eagle Eye registry by filing a GitHub issue. Validates each camera URL, checks for duplicates, and embeds a snapshot preview. Requires the 'gh' CLI installed and authenticated (gh auth login). Your local cameras are not removed — use remove_local after they are accepted.

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 13 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: adding/removing local cameras, fetching snapshots, searching, browsing, exploring, reporting, etc. No two tools overlap in functionality.

    Naming Consistency4/5

    Most tools follow a verb_noun pattern (e.g., add_local_camera, get_snapshot, list_cameras), but a few like 'explore_cameras' and 'nearby_cameras' deviate slightly. Overall, the naming is clear and intuitive.

    Tool Count5/5

    13 tools appropriately cover the core operations of a camera registry: CRUD for local cameras, search/discovery, snapshots, and registry interaction. The count feels neither sparse nor overwhelming.

    Completeness5/5

    The tool set covers the full lifecycle: discovering upstream cameras, managing local ones (add, remove, submit), fetching snapshots individually or in batches, and reporting issues. No obvious gaps for the intended domain.

    Maintenance

    ActivityActive
    ResponsivenessMostly unanswered

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that provides LLM agents with direct access to webcam hardware for capturing high-resolution photos and recording video sequences. It enables autonomous agents to monitor environments and interact with the physical world through standard Model Context Protocol tools.
      6
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that enables interaction with local camera devices to capture and process images. It allows LLMs to access video devices with configurable settings such as resolution, orientation, and image format.
      1
      MIT
    • A
      license
      Not graded
      quality
      A
      maintenance
      MCP server that enables AI agents to watch and analyze videos from 1800+ sources, with persistent indexing, OCR, transcription, and a self-verification loop for debugging.
      MIT