Is OpenSEO Compatible With Other SEO Tools? Complete Integration Guide

Yes, OpenSEO works alongside any SEO tool through its MCP (Model-Connect-Protocol) server, which exposes read-only JSON endpoints that return DataForSEO and Google Search Console data to any HTTP client.

OpenSEO is an open-source SEO platform from the every-app/open-seo repository designed for maximum interoperability. Rather than locking data behind a proprietary interface, it exposes a thin MCP (Model-Connect-Protocol) layer that returns the same underlying keyword, SERP, and backlink data consumed by commercial SEO suites, making it trivially compatible with external analytics workflows and AI agents.

How OpenSEO Achieves Cross-Platform Compatibility

The architecture separates data acquisition from consumption, enabling any tool that speaks HTTP to ingest OpenSEO metrics.

The MCP Server Architecture

At the core of OpenSEO's compatibility is its MCP (Model-Connect-Protocol) server, located in src/server/mcp/. This layer publishes JSON-RPC-style endpoints that wrap calls to the DataForSEO API and Google Search Console (GSC). Because the tools are read-only, they do not trigger DataForSEO credit consumption, allowing unlimited safe calls from external systems.

The data flow follows this stack:

1. Data Layer: Raw feeds from DataForSEO (paid) and GSC (free) via src/shared/rank-tracking.ts for cost handling and src/server/lib/gscClient.ts for the free GSC client.
2. Service Layer: Business logic that meters credits and normalizes responses.
3. MCP Layer: Exposes tools like get_search_console_performance, research_keywords, and get_backlinks_overview through HTTP POST endpoints.
4. Client Layer: Any HTTP consumer—whether Claude Code, Cursor, a Python script, or another SEO platform.

Read-Only, Credit-Free Operations

Tools defined in src/server/mcp/tools/whoami.ts demonstrate the credit-free pattern: they return project metadata without touching paid APIs. This design means you can poll the MCP endpoints from automation scripts without worrying about DataForSEO quotas, as implemented in the credit handling logic of src/shared/rank-tracking.ts.

Integration Patterns With Other SEO Tools

OpenSEO supports three primary interoperability modes, depending on whether you want to supplement, replace, or merge external data sources.

Run OpenSEO Alongside Existing Stacks

Use OpenSEO's MCP as a parallel data feed. For example, feed live GSC metrics into your existing rank-tracking dashboard while maintaining your current subscription to another SEO suite. The MCP simply provides an additional JSON stream that dual-writes to your data warehouse.

Replace Third-Party Data Sources

If a competitor product accepts DataForSEO credentials, point it at your self-hosted OpenSEO instance instead. The MCP forwards the same DataForSEO API responses, acting as a transparent proxy that adds your own credit metering and caching layers.

Merge Data Across Platforms

Combine free GSC data from OpenSEO with proprietary metrics from other tools. The get_search_console_performance tool returns clicks and impressions that you can join with backlink profiles from paid services, creating enriched datasets without duplicate API subscriptions.

Calling the MCP: Practical Examples

cURL Request to the MCP Endpoint

Query keyword research data from the command line using any tool that supports HTTP:

curl -X POST https://app.openseo.so/mcp \
  -H "Authorization: Bearer <your-mcp-token>" \
  -H "Content-Type: application/json" \
  -d '{
    "tool": "research_keywords",
    "params": {
      "projectId": "12345",
      "domain": "example.com",
      "keyword": "budget travel",
      "locationCode": 2840,
      "languageCode": 1000
    }
  }'

This returns the same keyword-research rows DataForSEO provides, but requires only an MCP token—no direct API key needed.

Node.js Integration Script

import fetch from "node-fetch";

async function researchKeywords() {
  const resp = await fetch("https://app.openseo.so/mcp", {
    method: "POST",
    headers: {
      "Authorization": "Bearer YOUR_MCP_TOKEN",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      tool: "research_keywords",
      params: {
        projectId: "12345",
        domain: "example.com",
        keyword: "budget travel",
        locationCode: 2840,
        languageCode: 1000
      }
    })
  });

  const data = await resp.json();
  console.log(data);
}

researchKeywords();

Self-Hosted Docker Deployment

For integrations requiring local network access or custom middleware:

docker run -d -p 3001:3000 \
  -e DATAFORSEO_API_KEY=BASE64_CREDENTIALS \
  ghcr.io/every-app/open-seo:latest

Then call the local MCP:

// Local MCP call (run on the same host)
await fetch("http://localhost:3001/mcp", { /* ... */ });

See docs/SELF_HOSTING_DOCKER.md in the repository for complete environment variable configuration.

Cross-Tool Data Aggregation

Merge GSC performance with backlink data from another provider:

async function mergeData(projectId) {
  const [gsc, backlinks] = await Promise.all([
    fetchMcp("get_search_console_performance", { projectId }),
    fetchMcp("get_backlinks_overview", { projectId })
  ]);

  // Attach GSC clicks/impressions to backlink rows
  const merged = backlinks.results.map(b => ({
    ...b,
    clicks: gsc.results.find(r => r.page === b.url)?.clicks ?? 0,
    impressions: gsc.results.find(r => r.page === b.url)?.impressions ?? 0
  }));

  console.log(merged);
}

Key Source Files for Integration

Understanding these files helps you customize the MCP behavior when connecting OpenSEO to external tools:

• src/shared/rank-tracking.ts: Implements DataForSEO cost calculation and credit metering, crucial for understanding which operations consume paid quotas.
• src/server/lib/gscClient.ts: The Google Search Console client that powers free, credit-free data retrieval in MCP tools.
• src/server/mcp/tools/whoami.ts: Reference implementation of a read-only MCP tool that operates without touching paid APIs.
• specs/0003-google-search-console-integration.md: Design specification detailing how GSC data flows into the MCP layer.
• web/content/docs/mcp.md: Public documentation for AI agent integration, including schema definitions for get_search_console_performance and research_keywords.
• docs/SELF_HOSTING_DOCKER.md: Deployment guide for running the MCP server in environments requiring VPN or firewall-restricted access.

Summary

• OpenSEO exposes a read-only MCP server that returns DataForSEO and GSC data via HTTP POST requests, compatible with any tool that parses JSON.
• The get_search_console_performance and research_keywords tools provide credit-free alternatives to direct API calls, as implemented in src/server/mcp/tools/.
• You can run OpenSEO alongside, replace data sources for, or merge data with existing SEO platforms without proprietary connectors.
• Self-hosting via Docker (ghcr.io/every-app/open-seo:latest) enables local integrations for sensitive or high-volume workflows.

Frequently Asked Questions

Can OpenSEO replace my existing SEO platform entirely?

While OpenSEO provides core rank tracking, keyword research, and backlink overview capabilities through its MCP tools, it functions best as a data infrastructure layer rather than a complete GUI replacement. You can use its JSON responses to power another platform's visualization layer, effectively replacing that tool's data backend while keeping its interface.

Does OpenSEO require a DataForSEO subscription to work with other tools?

No. The Google Search Console integration (src/server/lib/gscClient.ts) provides free search analytics data through the MCP without consuming DataForSEO credits. However, accessing keyword difficulty, SERP features, or backlink depth from DataForSEO requires valid credentials passed to the Docker container or environment.

Is the MCP API compatible with AI coding assistants like Claude or Cursor?

Yes. OpenSEO's MCP server follows the Model-Connect-Protocol specification explicitly designed for AI agents. The web/content/docs/mcp.md file documents how Claude Code, Codex, and Cursor can discover and invoke tools like get_search_console_performance using JSON-RPC over HTTP, making it compatible with agentic workflows.

How does OpenSEO handle API rate limits when integrated with other tools?

Rate limiting is managed in the service layer referenced in src/shared/rank-tracking.ts, where DataForSEO credits are metered. Because MCP tools are read-only and often served from cached GSC data or static responses (as shown in src/server/mcp/tools/whoami.ts), they bypass paid quotas. Direct DataForSEO calls are proxied through your own credentials, subject to your plan's limits rather than OpenSEO's.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}