# How OpenSEO Competitor Analysis Extracts Ranked Keywords and SERP Competitors

> Learn how OpenSEO extracts ranked keywords and SERP competitors using DataForSEO. Discover organic keywords and identify competing domains with our powerful tool.

- Repository: [Every App/open-seo](https://github.com/every-app/open-seo)
- Tags: how-to-guide
- Published: 2026-07-31

---

**OpenSEO extracts ranked keywords and SERP competitors by integrating with DataForSEO Labs endpoints, using `get_competitor_keywords` to retrieve organic keywords for a domain and `find_serp_competitors` to identify domains competing for specific target keywords.**

The `every-app/open-seo` repository implements a comprehensive competitor analysis system that automates SEO intelligence gathering. By leveraging DataForSEO’s Labs API, the platform surfaces critical competitive data including keyword positions, search volumes, and SERP visibility scores. This article examines the exact implementation details, file paths, and function signatures that power these capabilities.

## How Ranked Keywords Are Extracted

### The `get_competitor_keywords` Implementation

OpenSEO retrieves a competitor’s organic keyword portfolio through the **`get_competitor_keywords`** tool defined in [`src/server/features/onboarding/onboardingMarketTools.ts`](https://github.com/every-app/open-seo/blob/main/src/server/features/onboarding/onboardingMarketTools.ts) (lines 155-162). This tool forwards the request to `dfsClient.labs.getKeywords()`, passing the target domain as a parameter.

The DataForSEO endpoint returns a payload containing each keyword’s **position**, **search volume**, **keyword difficulty**, and **estimated traffic**. The service layer filters this response and formats it into a standardized array of objects:

```typescript
// src/server/features/onboarding/onboardingMarketTools.ts
export async function getCompetitorKeywords(domain: string) {
  const result = await dfsClient.labs.getKeywords({ domain });
  // Returns: [{ keyword, position, volume, difficulty, traffic }, …]
  return result.keywords;
}

```

The UI renders these results in sortable tables, allowing marketers to identify high-value keywords where competitors rank but their own domain does not.

## How SERP Competitors Are Identified

### The `find_serp_competitors` Tool

To discover who competes for specific target keywords, OpenSEO uses the **`find_serp_competitors`** tool implemented in [`src/server/mcp/tools/dataforseo-research-tools.ts`](https://github.com/every-app/open-seo/blob/main/src/server/mcp/tools/dataforseo-research-tools.ts) (around line 833). This tool accepts an array of 2-5 target keywords and invokes `client.labs.serpCompetitors()`.

According to the source code, the raw response includes each competitor’s **domain**, **visibility score**, **keyword coverage count**, and **estimated traffic**. The implementation applies filtering logic (lines 845-854) to remove entries with zero visibility and sorts the results by visibility in descending order:

```typescript
// src/server/mcp/tools/dataforseo-research-tools.ts
export async function findSerpCompetitors(keywords: string[]) {
  const raw = await dfsClient.labs.serpCompetitors({ keywords });
  
  const sorted = raw
    .filter(c => c.visibility > 0)               // Remove empty entries
    .sort((a, b) => b.visibility - a.visibility); // Highest visibility first
  
  return sorted.map(c => ({
    domain: c.domain,
    visibility: c.visibility,
    keywordCoverage: c.keywordCoverage,
    traffic: c.traffic
  }));
}

```

This processing ensures users receive a prioritized list of domains that pose the strongest competition for their target queries.

## Data Flow and Architecture

The competitor analysis workflow relies on a centralized client wrapper located in [`src/server/lib/dataforseo/client.ts`](https://github.com/every-app/open-seo/blob/main/src/server/lib/dataforseo/client.ts). This file exports `dfsClient` with methods like `fetchSerpCompetitors` and `fetchKeywords` that handle authentication, rate limiting, and error handling for the DataForSEO API.

When a user initiates analysis from the frontend (triggered in [`src/web/src/pages/competitor-analysis.tsx`](https://github.com/every-app/open-seo/blob/main/src/web/src/pages/competitor-analysis.tsx)), the system executes the appropriate tool based on input type:

1. **Domain input** → Triggers `get_competitor_keywords` → Returns ranked keyword data
2. **Keyword input** → Triggers `find_serp_competitors` → Returns competing domains

Both paths return JSON payloads that the UI consumes to render interactive grids and tables, enabling marketers to plan keyword gap analyses and content strategies.

## Summary

- **`get_competitor_keywords`** in [`src/server/features/onboarding/onboardingMarketTools.ts`](https://github.com/every-app/open-seo/blob/main/src/server/features/onboarding/onboardingMarketTools.ts) extracts organic keywords, positions, and difficulty scores for any domain using `dfsClient.labs.getKeywords()`.
- **`find_serp_competitors`** in [`src/server/mcp/tools/dataforseo-research-tools.ts`](https://github.com/every-app/open-seo/blob/main/src/server/mcp/tools/dataforseo-research-tools.ts) identifies SERP competitors for 2-5 target keywords via `client.labs.serpCompetitors()`, filtering by visibility and sorting results.
- The `dfsClient` wrapper in [`src/server/lib/dataforseo/client.ts`](https://github.com/every-app/open-seo/blob/main/src/server/lib/dataforseo/client.ts) manages all DataForSEO API communication, ensuring consistent error handling and response formatting.
- Both tools return structured data that powers the competitor analysis UI in [`src/web/src/pages/competitor-analysis.tsx`](https://github.com/every-app/open-seo/blob/main/src/web/src/pages/competitor-analysis.tsx).

## Frequently Asked Questions

### What DataForSEO endpoints does OpenSEO use for competitor analysis?

OpenSEO uses two primary DataForSEO Labs endpoints: the **Keywords** endpoint (accessed via `dfsClient.labs.getKeywords()`) to retrieve ranked keywords for a domain, and the **Serp Competitors** endpoint (accessed via `client.labs.serpCompetitors()`) to find domains competing for specific keywords. These provide position data, search volumes, visibility scores, and traffic estimates.

### How many keywords can I analyze at once with the SERP competitor tool?

The `find_serp_competitors` tool accepts between **2 and 5 target keywords** per request. This limitation ensures accurate competitor identification while maintaining API performance. For larger keyword sets, the system processes them in batches or recommends using the ranked keyword extraction method instead.

### What filtering logic applies to SERP competitor results?

The implementation in [`src/server/mcp/tools/dataforseo-research-tools.ts`](https://github.com/every-app/open-seo/blob/main/src/server/mcp/tools/dataforseo-research-tools.ts) filters out competitors with zero visibility scores and sorts the remaining results by visibility in descending order (lines 845-854). Additional filtering may remove explicit exclusions or domains below certain traffic thresholds before returning data to the frontend.

### Can I extract competitor keywords for any domain?

Yes, the `get_competitor_keywords` tool accepts any valid domain string as input. The system queries DataForSEO’s database for organic ranking data associated with that domain, returning keywords where the domain holds positions in Google’s SERPs along with corresponding metrics like volume and difficulty.