# What SERP Features Does OpenSEO Identify During Rank Tracking?

> Discover the SERP features OpenSEO identifies during rank tracking, including featured snippets, local packs, PAA, video carousels, and more. Get comprehensive SERP insights.

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

---

**OpenSEO identifies every SERP feature type returned by DataForSEO—including organic results, featured snippets, local packs, People Also Ask, video carousels, and shopping results—by extracting unique `type` strings from live Google SERP data and storing them in a `serpFeatures` array.**

OpenSEO is an open-source SEO platform that automates rank tracking by integrating with the DataForSEO API. During each rank check operation, the system captures not just position data, but also the specific SERP features OpenSEO identifies for every tracked keyword, enabling comprehensive competitive analysis.

## The Complete List of SERP Features OpenSEO Tracks

OpenSEO records any SERP element type that DataForSEO returns, storing raw type strings without filtering or renaming. This ensures the platform captures both standard results and rich features that dominate modern search results.

### Core Search Result Types

- **organic** – Standard blue-link search results
- **paid** – Google Ads and sponsored listings

### Rich Results and Knowledge Elements

- **featured_snippet** – Zero-click answer boxes positioned above organic results
- **knowledge_graph** – Entity panels appearing on the right side of results
- **people_also_ask** – FAQ-style accordion questions
- **site_links** – Additional links displayed under main results

### Local and Visual Elements

- **local_pack** – Map snippets featuring local businesses
- **video** – Video carousel results
- **image** – Image pack carousels
- **carousel** – General multi-card carousels including shopping
- **news** – Google News carousels
- **shopping** – Product listing ads and merchant results

Because OpenSEO uses the raw `type` values from DataForSEO, it automatically supports any new SERP features that Google introduces without requiring codebase updates.

## How OpenSEO Extracts SERP Features From DataForSEO

The extraction process happens in real-time during the rank check workflow, with data flowing from the DataForSEO API through to the database and UI layer.

### Fetching Live SERP Data

The `fetchRankCheckSerp` function in [`src/server/lib/dataforseo/serp.ts`](https://github.com/every-app/open-seo/blob/main/src/server/lib/dataforseo/serp.ts) calls DataForSEO's `googleOrganicLiveAdvanced` endpoint. This returns an array of `SerpLiveItem` objects, each containing a `type` property indicating the specific SERP feature present on the page.

### Building the Feature Array

Inside [`src/server/lib/dataforseo/serp.ts`](https://github.com/every-app/open-seo/blob/main/src/server/lib/dataforseo/serp.ts), the code constructs the `serpFeatures` array by mapping over SERP items and extracting unique type values:

```ts
serpFeatures: [...new Set(items.map((item) => item.type).filter(Boolean))],

```

This approach uses a JavaScript `Set` to deduplicate feature types while preserving the exact strings returned by DataForSEO.

### Database Storage Schema

The `RankCheckResult` type defined in [`src/types/schemas/rank-tracking.ts`](https://github.com/every-app/open-seo/blob/main/src/types/schemas/rank-tracking.ts) declares `serpFeatures` as a `string[]`. The database schema in [`src/db/app.schema.ts`](https://github.com/every-app/open-seo/blob/main/src/db/app.schema.ts) persists these features in a JSON column named `serp_features`, maintaining historical records of which features appeared for each keyword check.

### Rendering Features in the UI

The rank-tracking table component in [`src/client/features/rank-tracking/RankTrackingTableParts.tsx`](https://github.com/every-app/open-seo/blob/main/src/client/features/rank-tracking/RankTrackingTableParts.tsx) displays SERP features by joining the array into readable text:

```tsx
row.desktop.serpFeatures.join(", ")

```

The same pattern applies to mobile results, allowing side-by-side comparison of feature presence across devices.

## Working With SERP Feature Data in Code

Developers can access SERP feature data programmatically through the rank check API to build custom reports or trigger automations based on feature presence.

### Fetching SERP Features for Analysis

```ts
import { fetchRankCheckSerp } from "@/server/lib/dataforseo/serp";

async function getFeatures(keyword: string) {
  const resp = await fetchRankCheckSerp({
    keyword,
    keywordId: "kw‑123",
    locationCode: 2840,
    languageCode: "en",
    device: "desktop",
    targetDomain: "example.com",
    depth: 10,
  });

  // Returns: ["organic", "featured_snippet", "people_also_ask"]
  return resp.data.serpFeatures;
}

```

### Displaying Features in a React Component

```tsx
function SerpFeaturesCell({ features }: { features: string[] }) {
  return <span>{features.join(", ") || "‑"}</span>;
}

// Usage inside the rank-tracking table:
<SerpFeaturesCell features={row.desktop.serpFeatures} />

```

## Summary

- OpenSEO identifies **every SERP feature type** returned by DataForSEO, including organic, paid, featured snippets, local packs, and carousels.
- The system extracts features using a **unique set of type strings** from live SERP data in [`src/server/lib/dataforseo/serp.ts`](https://github.com/every-app/open-seo/blob/main/src/server/lib/dataforseo/serp.ts).
- Features are stored as a **string array** in the database via [`src/db/app.schema.ts`](https://github.com/every-app/open-seo/blob/main/src/db/app.schema.ts) and displayed in the UI through [`RankTrackingTableParts.tsx`](https://github.com/every-app/open-seo/blob/main/RankTrackingTableParts.tsx).
- Because the implementation uses raw DataForSEO type values, OpenSEO automatically supports **future SERP features** without code updates.

## Frequently Asked Questions

### Does OpenSEO identify SERP features for both desktop and mobile tracking?

Yes. The rank-tracking system separately records `serpFeatures` arrays for desktop and mobile devices. The UI renders these independently, allowing you to compare feature presence across devices using the `row.desktop.serpFeatures` and `row.mobile.serpFeatures` properties in [`RankTrackingTableParts.tsx`](https://github.com/every-app/open-seo/blob/main/RankTrackingTableParts.tsx).

### Can OpenSEO detect when a new SERP feature appears that isn't in its codebase?

Yes. Because the feature extraction logic in [`src/server/lib/dataforseo/serp.ts`](https://github.com/every-app/open-seo/blob/main/src/server/lib/dataforseo/serp.ts) uses a dynamic `Set` constructor on raw DataForSEO type strings, any new feature type added by DataForSEO is automatically captured and stored without requiring updates to OpenSEO's source code or type definitions.

### How does OpenSEO handle keywords that return no special SERP features?

When a SERP contains only standard results, the `serpFeatures` array will typically contain `["organic"]`. If DataForSEO returns no type data for certain items, the `filter(Boolean)` operation removes falsy values. The UI component handles empty arrays by displaying a dash ("‑") as a fallback value.

### Where is the SERP feature data stored in the database?

The features are persisted in the `serp_features` column (JSON type) defined in [`src/db/app.schema.ts`](https://github.com/every-app/open-seo/blob/main/src/db/app.schema.ts), which stores the string array alongside other rank check metadata such as position, URL, search depth, and timestamp.