# Google Rank & SERP Competitor Monitor (`feeng/google-rank-competitor-monitor`) Actor

🔎 Track a domain's Google positions, ranking gains and drops, competing domains, and top search results by keyword. No external SERP API key or Actor required.

- **URL**: https://apify.com/feeng/google-rank-competitor-monitor.md
- **Developed by:** [Daniel S.](https://apify.com/feeng) (community)
- **Categories:** SEO tools, Marketing, Business
- **Stats:** 2 total users, 0 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$8.00 / 1,000 google serp pages

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Google Rank & SERP Competitor Monitor

Track where your domain ranks in Google for target keywords, detect position gains and drops, and see which competitors own the top results. 🔎 Build daily or weekly ranking history without a Serper, SerpAPI, DataForSEO, or external Actor dependency.

The Actor uses Apify's built-in Google SERP proxy directly. No third-party API key or subscription is required.

### Why SEO teams use it ✨

- **📍 Exact positions:** find the ranking URL, title, snippet, and position for every keyword.
- **📈 Rank movement:** detect gains, losses, new entries, and dropouts against the previous run.
- **🏆 Competitor visibility:** capture the domains and URLs currently outranking the target.
- **🚨 Configurable alerts:** flag movements larger than a chosen number of positions.
- **📊 Portfolio reporting:** see ranked keywords, top-3/top-10 counts, average position, and visibility score.
- **🕒 Historical trends:** retain up to 365 position points per keyword with visual sparklines.

### Best use cases 🎯

- Daily Google keyword rank tracking
- SEO agency client reporting
- Competitor SERP monitoring
- Content performance and decay detection
- Affiliate and publisher ranking alerts
- Localized country and language checks

### Input

```json
{
  "domain": "apify.com",
  "keywords": ["web scraping platform", "google maps scraper"],
  "country": "us",
  "language": "en",
  "maxResults": 20,
  "compareWithPrevious": true,
  "saveHistory": true,
  "alertPositionChange": 3,
  "includeTopResults": true
}
````

The first run creates a baseline. Keep the same `monitorId`, country, language, and history store on future scheduled runs.

### Output 📦

Each successful keyword produces one dataset row with flat movement and competitor columns plus complete SERP evidence. Use the `overview`, `alerts`, `competitors`, and `allData` dataset views.

- target position, ranking URL, title, and snippet
- previous position and signed position change
- entered-results and dropped-out flags
- alert decision and plain-English change summary
- top competing domains and organic results
- People Also Ask and related searches when present
- historical position points and keyword visibility score

The Actor also saves `OUTPUT.json`, `OUTPUT.csv`, `RUN_SUMMARY.json`, `ERRORS.json`, and a self-contained `REPORT.html`.

### Pricing without hidden API subscriptions 💵

Recommended Pay per event price: **$0.008 per Google SERP page**. One page checks approximately 10 organic results.

- Top 10 for one keyword: $0.008
- Top 20 for one keyword: $0.016
- 25 keywords checked to top 20 daily: about $12/month
- 100 keywords checked to top 10 weekly: about $3.20/month

Charging by page aligns revenue with the built-in Google SERP proxy cost, so deeper top-100 checks remain sustainable. Failed keywords are not exported as paid results. Apify platform usage may be shown separately according to the user's plan.

### Schedule automatic rank tracking 🔁

1. Run once to create keyword baselines.
2. Save the input as an Apify Task.
3. Schedule daily or weekly runs.
4. Connect successful runs or dataset items to Slack, email, Sheets, Make, Zapier, n8n, or a client dashboard.

### SEO positioning 🚀

**Store title:** Google Rank & SERP Competitor Monitor

**SEO title:** Google Rank Tracker & SERP Competitor Monitor

**SEO description:** Track Google keyword positions, ranking gains and drops, competing domains, and top organic results by country. No external SERP API key required.

**Keywords:** Google rank tracker, SERP rank checker, keyword position monitor, SEO rank tracking, competitor SERP monitor, Google ranking API, daily keyword tracker, organic search positions, SEO reporting API.

### Reliability and limitations

- Google results vary by country, language, personalization, time, and device. The Actor disables personalized search signals where possible.
- Google SERP proxy is an Apify platform service and is required for reliable results.
- Organic layouts change over time; failed queries are separated in `ERRORS.json` rather than silently reported as unranked.
- The tool tracks public search results only and does not access Google Search Console or private analytics.

This is an unofficial independent tool and is not affiliated with, endorsed by, or sponsored by Google.

# Actor input Schema

## `domain` (type: `string`):

Domain to find in organic Google results, for example apify.com.

## `keywords` (type: `array`):

Search phrases to track. Each keyword produces one rank snapshot and uses one SERP page per 10 requested results.

## `country` (type: `string`):

Two-letter country code used for localized results, such as us, gb, de, or cz.

## `language` (type: `string`):

Google interface and result language code, such as en, de, fr, or cs.

## `maxResults` (type: `integer`):

Depth to check. Google SERP proxy returns about 10 organic results per paid page.

## `compareWithPrevious` (type: `boolean`):

Calculate ranking gains, losses, entries, dropouts, and competitor changes.

## `saveHistory` (type: `boolean`):

Persist ranking points for scheduled daily or weekly monitoring.

## `historyPoints` (type: `integer`):

Maximum chronological ranking points retained per keyword.

## `alertPositionChange` (type: `integer`):

Mark a keyword as an alert after this many gained or lost positions. Entries and dropouts always alert.

## `includeTopResults` (type: `boolean`):

Include the complete checked SERP in each keyword row. When disabled, only the top three are retained.

## `includeHtmlReport` (type: `boolean`):

Save a client-ready ranking report with portfolio metrics and history sparklines.

## `requestTimeoutSecs` (type: `integer`):

Maximum time for one Google SERP proxy request.

## `retryCount` (type: `integer`):

Retries for transient SERP request errors.

## `monitorId` (type: `string`):

Stable identifier separating client or project histories.

## `stateStoreName` (type: `string`):

Named key-value store used to preserve ranking history.

## `proxyConfiguration` (type: `object`):

Google SERP proxy is required and enabled by default. It is an Apify platform service, not another Actor or third-party API key.

## Actor input object example

```json
{
  "domain": "apify.com",
  "keywords": [
    "web scraping platform"
  ],
  "country": "us",
  "language": "en",
  "maxResults": 10,
  "compareWithPrevious": true,
  "saveHistory": true,
  "historyPoints": 90,
  "alertPositionChange": 3,
  "includeTopResults": true,
  "includeHtmlReport": true,
  "requestTimeoutSecs": 60,
  "retryCount": 1,
  "monitorId": "default",
  "stateStoreName": "google-rank-monitor-history",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

# Actor output Schema

## `rankings` (type: `string`):

No description

## `alerts` (type: `string`):

No description

## `competitors` (type: `string`):

No description

## `allData` (type: `string`):

No description

## `htmlReport` (type: `string`):

No description

## `csvExport` (type: `string`):

No description

## `jsonExport` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `errors` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domain": "apify.com",
    "keywords": [
        "web scraping platform"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("feeng/google-rank-competitor-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "domain": "apify.com",
    "keywords": ["web scraping platform"],
}

# Run the Actor and wait for it to finish
run = client.actor("feeng/google-rank-competitor-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domain": "apify.com",
  "keywords": [
    "web scraping platform"
  ]
}' |
apify call feeng/google-rank-competitor-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=feeng/google-rank-competitor-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Rank & SERP Competitor Monitor",
        "description": "🔎 Track a domain's Google positions, ranking gains and drops, competing domains, and top search results by keyword. No external SERP API key or Actor required.",
        "version": "0.1",
        "x-build-id": "xHMv17GkgT4al5KP0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/feeng~google-rank-competitor-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-feeng-google-rank-competitor-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/feeng~google-rank-competitor-monitor/runs": {
            "post": {
                "operationId": "runs-sync-feeng-google-rank-competitor-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/feeng~google-rank-competitor-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-feeng-google-rank-competitor-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "domain",
                    "keywords"
                ],
                "properties": {
                    "domain": {
                        "title": "Target domain",
                        "type": "string",
                        "description": "Domain to find in organic Google results, for example apify.com."
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Search phrases to track. Each keyword produces one rank snapshot and uses one SERP page per 10 requested results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Google country",
                        "type": "string",
                        "description": "Two-letter country code used for localized results, such as us, gb, de, or cz.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Search language",
                        "type": "string",
                        "description": "Google interface and result language code, such as en, de, fr, or cs.",
                        "default": "en"
                    },
                    "maxResults": {
                        "title": "Maximum organic results per keyword",
                        "minimum": 10,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Depth to check. Google SERP proxy returns about 10 organic results per paid page.",
                        "default": 10
                    },
                    "compareWithPrevious": {
                        "title": "Compare with previous run",
                        "type": "boolean",
                        "description": "Calculate ranking gains, losses, entries, dropouts, and competitor changes.",
                        "default": true
                    },
                    "saveHistory": {
                        "title": "Save ranking history",
                        "type": "boolean",
                        "description": "Persist ranking points for scheduled daily or weekly monitoring.",
                        "default": true
                    },
                    "historyPoints": {
                        "title": "History points per keyword",
                        "minimum": 2,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Maximum chronological ranking points retained per keyword.",
                        "default": 90
                    },
                    "alertPositionChange": {
                        "title": "Ranking alert threshold",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Mark a keyword as an alert after this many gained or lost positions. Entries and dropouts always alert.",
                        "default": 3
                    },
                    "includeTopResults": {
                        "title": "Include all checked organic results",
                        "type": "boolean",
                        "description": "Include the complete checked SERP in each keyword row. When disabled, only the top three are retained.",
                        "default": true
                    },
                    "includeHtmlReport": {
                        "title": "Generate visual report",
                        "type": "boolean",
                        "description": "Save a client-ready ranking report with portfolio metrics and history sparklines.",
                        "default": true
                    },
                    "requestTimeoutSecs": {
                        "title": "SERP request timeout",
                        "minimum": 10,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Maximum time for one Google SERP proxy request.",
                        "default": 60
                    },
                    "retryCount": {
                        "title": "Retries",
                        "minimum": 0,
                        "maximum": 3,
                        "type": "integer",
                        "description": "Retries for transient SERP request errors.",
                        "default": 1
                    },
                    "monitorId": {
                        "title": "Monitor ID",
                        "type": "string",
                        "description": "Stable identifier separating client or project histories.",
                        "default": "default"
                    },
                    "stateStoreName": {
                        "title": "History store name",
                        "type": "string",
                        "description": "Named key-value store used to preserve ranking history.",
                        "default": "google-rank-monitor-history"
                    },
                    "proxyConfiguration": {
                        "title": "Google SERP proxy",
                        "type": "object",
                        "description": "Google SERP proxy is required and enabled by default. It is an Apify platform service, not another Actor or third-party API key.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "GOOGLE_SERP"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
