[Cotlet](https://cotlet.dev/index.md) · [Integrations](https://cotlet.dev/integrations.md) · [How it works](https://cotlet.dev/how-it-works.md) · [Use cases](https://cotlet.dev/use-cases.md) · [Security](https://cotlet.dev/security.md) · [For developers](https://cotlet.dev/for-developers.md) · [For automation agencies](https://cotlet.dev/for-agencies.md) · [Blog](https://cotlet.dev/blog.md) · [API docs](https://cotlet.dev/docs.md) · [Help center](https://cotlet.dev/help.md) · [Changelog](https://cotlet.dev/changelog.md) · [Contact](https://cotlet.dev/contact.md) · [Pricing](https://cotlet.dev/pricing.md) · [Sign up](https://cotlet.dev/signup)

# Google Search Console API and MCP server

> Google Search Console has an API, but it covers only part of the web interface (checked 16 Oct 2026). It offers Search Analytics queries (with an hourly breakdown for up to 10 days), sitemap list, get, submit and delete, property list, get, add and delete, and read-only URL Inspection of the indexed version. It cannot request indexing, run a live test, list not-indexed URLs, read the Links report, file removals or manage users.

Google's free tool for site owners: clicks and impressions from Google Search, which pages are indexed and why others are not, links, sitemaps, removals and who has access to each property.

## What is the Google Search Console API?

Cotlet's Google Search Console API exposes 15 endpoints for your own Google Search Console account: get performance stats, inspect URL, test live URL, list pages by index status, list page issues, list sitemaps, get links report, list users, list removals, request indexing, validate fix, submit sitemap, request URL removal, add user and remove user. The get_performance_stats endpoint returns clicks, impressions, CTR and average position by query, page, country, device, search appearance, date or hour. Each endpoint takes simple JSON inputs like property, url or limit and works both as an operation of the google_search_console_read or google_search_console_write MCP tool for agents and as a REST call for scripts.

- **Category:** [Marketing & SEO](https://cotlet.dev/integrations/category/marketing-seo.md)
- **Endpoints:** 15 (9 read, 6 write)
- **Updated:** 2026-10-21

Google Search Console has an API, but it covers only part of the web interface (checked 16 Oct 2026). Cotlet is a hosted MCP server and REST API for Google Search Console with 15 endpoints (9 read, 6 write): you sign in once in your own cloud browser, your AI agent does the work.

## Does Google Search Console have an official API?

Google Search Console has an API, but it covers only part of the web interface (checked 16 Oct 2026). It offers Search Analytics queries (with an hourly breakdown for up to 10 days), sitemap list, get, submit and delete, property list, get, add and delete, and read-only URL Inspection of the indexed version. It cannot request indexing, run a live test, list not-indexed URLs, read the Links report, file removals or manage users.

| Task | Google Search Console official | Cotlet |
|---|---|---|
| Request indexing of a URL | No: The Indexing API is limited to job posting and livestream pages | Yes |
| Inspect the indexed version of a URL | Yes: URL Inspection API, read-only, 2,000 queries a day per site | Yes |
| Test a live URL | No: Only in the URL Inspection tool of the web interface | Yes |
| List not-indexed URLs per reason and validate a fix | No | Yes |
| Links report: linking sites, linked pages, internal links, linking text | No | Yes |
| Add, list and remove users on a property | No | Yes |
| Temporary URL removals | No | Yes |
| Performance stats (incl. hourly) and sitemaps | Yes: searchAnalytics.query and the sitemaps methods; our value is one key and one MCP server for everything | Yes |

Sources: [Search Console API: resources and methods](https://developers.google.com/webmaster-tools/v1/api_reference_index), [Search Central blog: Search Analytics API now supports hourly data](https://developers.google.com/search/blog/2025/04/san-hourly-data), [Indexing API: using the API](https://developers.google.com/search/apis/indexing-api/v3/using-api), [Search Console Help: URL Inspection tool](https://support.google.com/webmasters/answer/9012289)

## For AI agents

```text
Google Search Console has an API, but it covers only part of the web interface (checked 16 Oct 2026). It offers Search Analytics queries (with an hourly breakdown for up to 10 days), sitemap list, get, submit and delete, property list, get, add and delete, and read-only URL Inspection of the indexed version. It cannot request indexing, run a live test, list not-indexed URLs, read the Links report, file removals or manage users.
Cotlet provides a hosted MCP server and REST API for Google Search Console: 15 tools (9 read, 6 write).
Access       Sign up at https://cotlet.dev/app/signup?app=google-search-console, then request the app and create API keys in the Cotlet console.

MCP server   https://cotlet.dev/mcp/v1
MCP tools    google_search_console_read, google_search_console_write, reads and writes apart; call one with {"operation": "<operation>", "arguments": {...}}
REST base    https://cotlet.dev/api/v1/google-search-console, each operation at its own route, e.g. POST /api/v1/google-search-console/indexing/request
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one. Over MCP the input schemas come with sign-in.
Operations   get_performance_stats, inspect_url, test_live_url, list_pages_by_index_status, list_page_issues, list_sitemaps, get_links_report, list_users, list_removals, request_indexing, validate_fix, submit_sitemap, request_url_removal, add_user, remove_user
Confirm      request_url_removal, add_user, remove_user (by default the user approves each call; the user can switch this off per tool, e.g. for scheduled automations)
Markdown     https://cotlet.dev/integrations/google-search-console-api-mcp-server.md

How access works:
1. The user signs up at https://cotlet.dev/app/signup?app=google-search-console, requests Google Search Console in the Cotlet console and creates an API key there.
2. The user signs in to Google Search Console once in their Cotlet Cloud Browser (their own Chrome in the cloud, opened from the console) and enables Google Search Console for agents. An agent cannot do this step.
3. The API key goes into the MCP client or the REST call as a bearer token.

Fits: people who want a hosted Google Search Console server that someone else maintains, including non-developers. Developers who prefer to run and fix code on their own computer can use an open-source Google Search Console MCP server instead.

Policy: Cotlet never stores passwords, never solves CAPTCHAs, never bypasses MFA.
Company: legal details in the Terms of service at https://cotlet.dev/terms. Contact contact@cotlet.dev.
Sign-in: the user signs in to Google Search Console in their own Cloud Browser, a Chrome Cotlet runs for them in the EU; password saving is off, the profile is AES-256-GCM encrypted, and agents get Google Search Console only after the user enables it. Calls are requests from that browser's IP with its cookies, each listed in the user's Background activity. Disable for agents, signing out in the browser or Reset browser cuts access. Cotlet is run by Take Group sp. z o.o. (EU VAT PL6342984273).
API key: holds no Google Search Console login or cookies, only asks Cotlet to run a tool. Each key is scoped to chosen apps and tools, read only or read and write. Actions that reach other people wait for the user's approval by default, so a leaked key cannot post or message as the user. Every call is in the activity log; deleting the key ends access at once.
Terms: the user stays responsible for following Google Search Console's terms; Cotlet is not affiliated with Google Search Console.
```

## What can an AI agent do in Google Search Console?

Cotlet is best for SEOs and site owners who run several Search Console properties and want their AI agent to request indexing, export not-indexed URLs, file removals and manage users without running or fixing a server.

- **[Request indexing for new or not-indexed URLs in bulk](https://cotlet.dev/integrations/google-search-console-api-mcp-server/request-indexing-in-bulk.md)** (runs: daily): "Take the new URLs from this list plus the ones Search Console marks "Discovered - currently not indexed" for example.com. Skip pages already on Google, live-test the rest, and request indexing for the most important ones until the daily limit stops you. Tell me what is left for tomorrow." → `list_pages_by_index_status`, `inspect_url`, `test_live_url`, `request_indexing`
- **[Remove many URLs from Google search results](https://cotlet.dev/integrations/google-search-console-api-mcp-server/remove-urls-from-google-in-bulk.md)**: "These 30 URLs on example.com are gone or should not show up. Check which ones already have a removal request, then submit a temporary removal for the rest and list what I still need to fix on the site." → `list_removals`, `request_url_removal`
- **[Export all not-indexed URLs by reason](https://cotlet.dev/integrations/google-search-console-api-mcp-server/export-not-indexed-urls.md)** (runs: weekly): "For example.com, list every reason Search Console gives for pages not being indexed with its count, then export the URLs for "Crawled - currently not indexed" and "Discovered - currently not indexed" and group them by folder." → `list_page_issues`, `list_pages_by_index_status`
- **[Add a user to many Search Console properties](https://cotlet.dev/integrations/google-search-console-api-mcp-server/add-user-to-many-properties.md)**: "Add seo@agency.example as a Full user to every property in this list: example.com, example.org, shop.example.com. Skip the ones where she already has access and tell me if any property is close to its user limit." → `list_users`, `add_user`
- **Check the last 24 hours of clicks every morning** (runs: daily): "Every morning, pull clicks and impressions for example.com by hour for the last 24 hours, compare them with the same hours a week ago and tell me if a page or query dropped." → `get_performance_stats`
- **Export the Links report every week** (runs: weekly): "Every Monday, export top linking sites, top linked pages and top linking text for example.com and tell me which linking sites are new since last week." → `get_links_report`

## Can Google Search Console automations run on a schedule in n8n, Make or Zapier?

Yes. Cotlet does not replace your automation platform: it gives it a Google Search Console connection it does not have, with the same API key as your agent. Write actions ask for your OK by default; switch that off in your dashboard for the tools you choose, for example to request indexing for new or not-indexed urls in bulk, and the schedule runs on its own. Cotlet runs in the cloud, so it keeps going while your computer is off.

| Where | How to connect | How to schedule |
|---|---|---|
| Your AI agent | Add https://cotlet.dev/mcp/v1 with your API key. | A scheduled agent run, for example a Claude Code routine. |
| n8n | MCP Client node with https://cotlet.dev/mcp/v1, or an HTTP Request node with the endpoint's method and URL, such as GET https://cotlet.dev/api/v1/google-search-console/pages-by-index-status. | Schedule Trigger node. |
| Make | HTTP module: the endpoint's method and URL with an Authorization: Bearer header, and a JSON body for POST, PUT and PATCH. | Scenario schedule. |
| Zapier | Webhooks by Zapier, Custom Request: the same method, URL, header and body. | Schedule by Zapier trigger. |
| Your own script | GET https://cotlet.dev/api/v1/google-search-console/pages-by-index-status with your API key. | cron or GitHub Actions. |

## Tools

**For AI agents:** Every endpoint and its schema is public. The 15 endpoints on this page, with parameters and example responses, can be listed without an account. Calling one returns 401 without an API key and 403 while the key has no access to Google Search Console.

### get_performance_stats

Clicks, impressions, CTR and average position by query, page, country, device, search appearance, date or hour. Access: read. REST: `GET /api/v1/google-search-console/performance-stats`. MCP: `google_search_console_read → get_performance_stats`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |
| `range` | enum | no | last_24_hours, last_7_days, last_28_days, last_3_months or custom. Default: last_28_days. |
| `start_date` | date | no | First day, with range custom. |
| `end_date` | date | no | Last day, with range custom. |
| `dimensions` | array | no | Any of query, page, country, device, search_appearance, date, hour. |
| `filter` | string | no | Optional filter, e.g. page contains '/guides/' or query contains 'api'. |
| `limit` | integer | no | 1 to 1000. Default: 100. |
| `cursor` | string | no | Next page cursor from the previous call. |

Returns the Performance report of a property for a date range, grouped by the dimensions you choose. The hour dimension gives hourly rows for the last 24 hours, the same 24-hour view the report has, or for up to 10 days back; hourly rows include preliminary data for the latest hours. CTR is clicks divided by impressions, and average position is the position of the topmost result from your site. Rows come ordered by clicks, highest first; pass next_cursor back as cursor for the next page.

Example response:

```json
{
  "property": "sc-domain:example.com",
  "dimensions": [
    "hour"
  ],
  "rows": [
    {
      "hour": "2026-10-16T08:00:00-07:00",
      "clicks": 142,
      "impressions": 3980,
      "ctr": 0.0357,
      "position": 11.4
    },
    {
      "hour": "2026-10-16T09:00:00-07:00",
      "clicks": 171,
      "impressions": 4410,
      "ctr": 0.0388,
      "position": 10.9
    }
  ],
  "includes_preliminary_data": true,
  "next_cursor": null
}
```

### inspect_url

Index status of a URL: the most recently indexed version, last crawl and canonical. Access: read. REST: `GET /api/v1/google-search-console/urls/inspect`. MCP: `google_search_console_read → inspect_url`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |
| `url` | string | yes | Full URL inside the property, e.g. https://example.com/blog/new-post. |

Returns what the URL Inspection tool shows for the indexed version of a page: status ("URL is on Google", "URL is on Google, but has issues", "URL is not on Google" or "URL is an alternate version"), discovery by sitemap and referring page, last crawl, crawled as, crawl allowed, page fetch, indexing allowed, and the user-declared and Google-selected canonical. It does not fetch the live page; use test_live_url for that. "On Google" means eligible, not guaranteed to appear. The URL must be inside the property.

Example response:

```json
{
  "url": "https://example.com/guides/search-console-api",
  "status": "URL is not on Google",
  "coverage": "Discovered - currently not indexed",
  "sitemap": "https://example.com/sitemap.xml",
  "referring_page": "https://example.com/guides",
  "last_crawl": null,
  "crawled_as": null,
  "crawl_allowed": null,
  "page_fetch": null,
  "indexing_allowed": null,
  "user_canonical": null,
  "google_canonical": null
}
```

### test_live_url

Fetch a page in real time and see whether Google could index it. Access: read. REST: `GET /api/v1/google-search-console/live-urls/test`. MCP: `google_search_console_read → test_live_url`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |
| `url` | string | yes | Full URL inside the property, e.g. https://example.com/blog/new-post. |

Runs Test live URL from the URL Inspection tool: Google fetches the page now and reports crawl, fetch and indexing-allowed results, and a screenshot link when the test succeeds. The page must be reachable from the internet without a login. The test does not check sitemaps, referring pages or canonical status, and it follows redirects without showing the final URL. Google keeps a daily limit of live inspections per property and publishes no number; the call fails with quota_exceeded when it is spent.

Example response:

```json
{
  "url": "https://example.com/guides/search-console-api",
  "live_status": "URL can be indexed",
  "page_fetch": "Successful",
  "crawl_allowed": true,
  "indexing_allowed": true,
  "screenshot": "available",
  "quota": "available"
}
```

### list_pages_by_index_status

URLs from the Page indexing report: the indexed ones, or the ones for a not-indexed reason. Access: read. REST: `GET /api/v1/google-search-console/pages-by-index-status`. MCP: `google_search_console_read → list_pages_by_index_status`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |
| `status` | string | yes | indexed, or a reason from the report: 'Crawled - currently not indexed', 'Discovered - currently not indexed', 'Not found (404)', "URL marked 'noindex'", 'Soft 404', 'Server error (5xx)', 'Duplicate without user-selected canonical' and the others the report shows. |
| `limit` | integer | no | 1 to 1000. Default: 100. |
| `cursor` | string | no | Next page cursor from the previous call. |

Returns the example URLs Google lists on the Page indexing report for one status, with the last crawl date. Google caps that list at 1,000 rows and does not guarantee it holds every URL, so the response says how many rows exist against the count on the report. Sources other than Website are shown but usually cannot be fixed by you. Pass next_cursor back as cursor for the next page.

Example response:

```json
{
  "property": "sc-domain:example.com",
  "status": "Crawled - currently not indexed",
  "pages_in_report": 1412,
  "rows_available": 1000,
  "rows": [
    {
      "url": "https://example.com/tag/seo",
      "last_crawled": "2026-10-09"
    },
    {
      "url": "https://example.com/tag/api",
      "last_crawled": "2026-10-08"
    },
    {
      "url": "https://example.com/blog/page/14",
      "last_crawled": "2026-10-02"
    }
  ],
  "next_cursor": "eyJvZmZzZXQiOjN9"
}
```

### list_page_issues

Indexing and page experience issues of a property with their URL count and validation state. Access: read. REST: `GET /api/v1/google-search-console/page-issues`. MCP: `google_search_console_read → list_page_issues`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |
| `kind` | enum | no | not_indexed or page_experience. Default: not_indexed. |

Returns the rows of the "Why pages aren't indexed" table and the "Improve page experience" table: the reason, its source, the number of pages and, if a fix was submitted, the validation state (Not started, Started, Looking good, Passed or Failed). Use the reason as status in list_pages_by_index_status. An issue drops off the table 90 days after its last instance is gone.

Example response:

```json
{
  "property": "sc-domain:example.com",
  "indexed_pages": 5820,
  "issues": [
    {
      "reason": "Crawled - currently not indexed",
      "source": "Google systems",
      "pages": 1412,
      "validation": "Not started"
    },
    {
      "reason": "Discovered - currently not indexed",
      "source": "Google systems",
      "pages": 388,
      "validation": "Not started"
    },
    {
      "reason": "Not found (404)",
      "source": "Website",
      "pages": 64,
      "validation": "Started"
    }
  ]
}
```

### list_sitemaps

Sitemaps of a property with last read date, status and discovered pages. Access: read. REST: `GET /api/v1/google-search-console/sitemaps`. MCP: `google_search_console_read → list_sitemaps`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |

Lists what the Sitemaps report shows: sitemap URL, type, date of the last submit, last read, status (Success, Has errors or Couldn't fetch) and the number of discovered pages. Discovered means parsed from the file, not crawled or indexed. The report lists only sitemaps sent through the report or the API, up to 1,000.

Example response:

```json
{
  "sitemaps": [
    {
      "url": "https://example.com/sitemap.xml",
      "type": "Sitemap index",
      "submitted": "2026-09-02",
      "last_read": "2026-10-15",
      "status": "Success",
      "discovered_pages": 7620
    }
  ]
}
```

### get_links_report

Top linking sites, top linked pages, internal links and top linking text of a property. Access: read. REST: `GET /api/v1/google-search-console/links-report`. MCP: `google_search_console_read → get_links_report`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |
| `table` | enum | yes | top_linking_sites, top_linked_pages, internal_links or top_linking_text. |
| `limit` | integer | no | 1 to 1000. Default: 100. |
| `cursor` | string | no | Next page cursor from the previous call. |

Returns one table of the Links report: top linking sites (root domains, subdomains are merged), top linked pages, internal links, or top linking text (external links only, matched case-insensitively). Google limits each table to 1,000 rows and the report is a sample of links, not a full list. Links without anchor text show as (empty).

Example response:

```json
{
  "property": "sc-domain:example.com",
  "table": "top_linking_sites",
  "rows": [
    {
      "site": "newsletter.example.net",
      "links": 214,
      "linked_pages": 18
    },
    {
      "site": "blog.example.org",
      "links": 96,
      "linked_pages": 9
    }
  ],
  "next_cursor": null
}
```

### list_users

Users of a property with their permission: owner, full or restricted. Access: read. REST: `GET /api/v1/google-search-console/users`. MCP: `google_search_console_read → list_users`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |

Lists the people on the Users and permissions screen of a property with their permission. Owners are verified or delegated; full users have view rights to all data and can take some actions; restricted users have view rights on most data. The response includes the count of non-owner users, because Google allows at most 100 per property.

Example response:

```json
{
  "property": "sc-domain:example.com",
  "non_owner_users": 1,
  "users": [
    {
      "email": "anna@example.com",
      "permission": "owner",
      "owner_type": "verified"
    },
    {
      "email": "seo@agency.example",
      "permission": "full"
    }
  ]
}
```

### list_removals

Removal requests of a property from the last 6 months with type and status. Access: read. REST: `GET /api/v1/google-search-console/removals`. MCP: `google_search_console_read → list_removals`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |

Lists the request history of the Removals tool, which covers the past 6 months: the URL or prefix, the type (Temporarily remove URL or Clear snippet in search) and the status. A successful temporary removal lasts only about six months. Use it before request_url_removal to avoid filing a URL twice.

Example response:

```json
{
  "removals": [
    {
      "request_id": "rm_7f3a",
      "url": "https://example.com/old-promo/",
      "scope": "prefix",
      "type": "temporarily_remove_url",
      "status": "active",
      "requested": "2026-09-21"
    }
  ]
}
```

### request_indexing

Press Request indexing for one URL, which puts it in Google's indexing queue. Access: write. REST: `POST /api/v1/google-search-console/indexing/request`. MCP: `google_search_console_write → request_indexing`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |
| `url` | string | yes | Full URL inside the property, e.g. https://example.com/blog/new-post. |

Presses Request indexing in the URL Inspection tool. If the page passes a quick check, Google adds it to the indexing queue, and refuses when the live test finds the page non-indexable. Request indexing allows about 10 requests a day per Google account, shared across all its properties; every call spends one, and when it is spent the call returns quota_exceeded and submits nothing. A request does not guarantee the page appears in Google. It reaches no one, so it runs without asking first; the agent counts the quota instead.

Example response:

```json
{
  "url": "https://example.com/guides/search-console-api",
  "status": "requested",
  "indexed_before": false,
  "quota": "available",
  "note": "Google queues the URL after a quick check. Indexing usually takes about a day but can take much longer."
}
```

### validate_fix

Start Google's validation of a fixed indexing or page experience issue. Access: write. REST: `POST /api/v1/google-search-console/fix/validate`. MCP: `google_search_console_write → validate_fix`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |
| `reason` | string | yes | Issue as shown by list_page_issues, e.g. Not found (404). |

Clicks Validate fix on an issue after you fixed every instance; validation stops when Google finds a single remaining instance. Search Console first checks a few pages, then queues only the URLs with known instances for recrawling. It typically takes up to about two weeks and can take much longer, and Google emails the progress. Do not call it again until validation has succeeded or failed. It reaches no one and changes nothing on your site, so it runs without asking first.

Example response:

```json
{
  "property": "sc-domain:example.com",
  "reason": "Not found (404)",
  "validation": "Started",
  "urls_queued": 64,
  "note": "Validation typically takes up to about two weeks."
}
```

### submit_sitemap

Tell Google where a sitemap is, or resubmit it. Owner or Full user. Access: write. REST: `POST /api/v1/google-search-console/sitemap/submit`. MCP: `google_search_console_write → submit_sitemap`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |
| `sitemap_url` | string | yes | Exact sitemap URL, e.g. https://example.com/sitemap.xml. |

Submits a sitemap URL in the Sitemaps report. Submitting only tells Google where the file is; it is fetched right away, but the listed URLs may take time to be crawled and some never are. Redirects are not followed, so give the exact URL. You need Owner or Full user permission. It reaches no one and is undone by removing the sitemap, so it runs without asking first.

Example response:

```json
{
  "property": "sc-domain:example.com",
  "sitemap": "https://example.com/sitemap.xml",
  "status": "submitted"
}
```

### request_url_removal

Temporarily remove a URL or prefix from Google results, or clear its snippet. Owner or Full user. Access: write, asks the user first. REST: `POST /api/v1/google-search-console/url-removal/request`. MCP: `google_search_console_write → request_url_removal`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |
| `url` | string | yes | Full URL inside the property, e.g. https://example.com/blog/new-post. |
| `type` | enum | yes | temporarily_remove_url or clear_snippet. |
| `scope` | enum | no | url_only or prefix. Default: url_only. |

Files a request in Removals > Temporary removals: Temporarily remove URL hides the page from results for about six months, Clear snippet in search wipes the description until the page is indexed again. Scope is this URL only or all URLs with a prefix, which can hide a whole folder or site. Google says requests usually take up to a day and are not guaranteed to be accepted, and blocking does not stop crawling. For a permanent removal the page needs a 404 or 410, a password or noindex. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "request_id": "rm_9c21",
  "url": "https://example.com/old-promo/spring-sale",
  "type": "temporarily_remove_url",
  "scope": "url_only",
  "status": "pending",
  "lasts": "about 6 months"
}
```

### add_user

Give a Google account access to a property as owner, full or restricted user. Owners only. Access: write, asks the user first. REST: `POST /api/v1/google-search-console/users`. MCP: `google_search_console_write → add_user`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |
| `email` | string | yes | Google Account email of the new user. |
| `permission` | enum | yes | owner, full or restricted. |

Adds a user in Settings > Users and permissions. The email must be a valid Google Account; an email group cannot be added. Permission is owner (a delegated owner), full or restricted. A property can have at most 100 non-owner users. You must be an owner of the property, or of its parent property. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "property": "sc-domain:example.com",
  "email": "seo@agency.example",
  "permission": "full",
  "status": "added",
  "non_owner_users": 8
}
```

### remove_user

Remove a user from a property. Owners only. Access: write, asks the user first. REST: `DELETE /api/v1/google-search-console/users`. MCP: `google_search_console_write → remove_user`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property` | string | yes | Property as Search Console lists it: sc-domain:example.com for a Domain property, https://example.com/ for a URL-prefix property. |
| `email` | string | yes | Email of the user to remove, as shown by list_users. |

Removes a user in Settings > Users and permissions; the person loses access to the property at once. A delegated owner can be removed here, but a verified owner has to be removed by removing their verification token from the site, so the call reports it instead. You must be an owner of the property, or of its parent property. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "property": "sc-domain:example.com",
  "email": "jane@oldagency.example",
  "status": "removed",
  "non_owner_users": 8
}
```

## How do I connect Google Search Console to Claude Code, Codex or Cursor?

Connecting Google Search Console takes three steps: sign up, sign in to Google Search Console once in your Cloud Browser and enable it for agents, then add one MCP server or call the REST API with the same key.

### Connect Google Search Console to your agent.

1. **Create an account** Sign up and add Google Search Console in the console. Your API key is there too.

2. **Sign in to Google Search Console in your Cloud Browser** Open your Cloud Browser in the console: your own Chrome in the cloud. Sign in to Google Search Console there yourself, the way you always do, then press Enable for agents, read only or read and write. We never save your password, and your agent keeps working even when your computer is off.

3. **Add Cotlet to your agent** Paste the snippet for your client. The same server and key serve every app you connect, so you do this once.

   Claude Code:

```
claude mcp add --transport http cotlet \
  https://cotlet.dev/mcp/v1 \
  --header "Authorization: Bearer $COTLET_API_KEY"
```

   Cursor:

```
{
  "mcpServers": {
    "cotlet": {
      "url": "https://cotlet.dev/mcp/v1",
      "headers": {
        "Authorization": "Bearer ${COTLET_API_KEY}"
      }
    }
  }
}
```

   Codex:

```
# ~/.codex/config.toml
[mcp_servers.cotlet]
url = "https://cotlet.dev/mcp/v1"
bearer_token_env_var = "COTLET_API_KEY"
```

4. **Ask your agent** Ask in plain words. Your agent finds the Google Search Console tools on the server and calls them for you; anything that reaches other people waits for your OK unless you switch that off for a tool.

```
Take the new URLs from this list plus the ones Search Console marks "Discovered - currently not indexed" for example.com. Skip pages already on Google, live-test the rest, and request indexing for the most important ones until the daily limit stops you. Tell me what is left for tomorrow.
```

### Call Google Search Console from your scripts.

1. **Export your API key** Your scripts use the same API key as your agent. Keep it in an environment variable, never in your code.

```
export COTLET_API_KEY="cotlet_..."
```

2. **Call a tool** Every tool is an endpoint under /api/v1/google-search-console with its own method and path, listed with the endpoints above. Path parameters go in the URL; the other parameters go in the query for GET and DELETE and in a JSON body otherwise.

```
curl -X POST https://cotlet.dev/api/v1/google-search-console/indexing/request \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"property":"sc-domain:example.com","url":"https://example.com/guides/search-console-api"}'
```

3. **Read the result** You get plain JSON back, ready for your script. A failed call costs nothing.

```
{
  "url": "https://example.com/guides/search-console-api",
  "status": "requested",
  "indexed_before": false,
  "quota": "available",
  "note": "Google queues the URL after a quick check. Indexing usually takes about a day but can take much longer."
}
```

## Why use Cotlet for Google Search Console?

**Built for agents**

- One MCP server for every app you connect.
- The same tools as a REST API for scripts and cron jobs.
- Works with Claude Code, Codex and Cursor.

**Your login stays yours**

- You sign in to Google Search Console yourself, in your own Cloud Browser. We never save your password; the profile is encrypted with AES-256-GCM, the cipher 1Password uses.
- A+ on Qualys SSL Labs, securityheaders.com and Mozilla Observatory.
- The model never sees a login.
- No stored passwords, no CAPTCHA solving, no MFA bypass.

**You stay in control**

- Scope each API key: its apps, its tools, read only or read and write.
- Anything that reaches other people waits for your OK, so a leaked key cannot post or message as you.
- Every background request listed in your Background activity. Disable for agents in one click.

**Kept working for you**

- We test every integration every 6 hours.
- When Google Search Console changes, the tool pauses until we fix it.
- Failed calls cost nothing.

## Is it safe to connect Google Search Console to Cotlet?

Yes. You sign in to Google Search Console yourself, in your own Cloud Browser, and we never save your password. Your agents only get Google Search Console once you enable it, and every background request is listed. The browser profile is stored encrypted with AES-256-GCM, the same cipher 1Password uses for its vaults and Apple for iCloud Keychain. Independent public scanners grade cotlet.dev A+ and find it clean; click a result to rerun it yourself.

- **A+ on Qualys SSL Labs**: Encryption in transit: TLS setup and certificates, on all four server addresses. [Live result](https://www.ssllabs.com/ssltest/analyze.html?d=cotlet.dev)
- **A+ on securityheaders.com**: Browser protections sent with every page, all six headers present. [Live result](https://securityheaders.com/?q=cotlet.dev&followRedirects=on)
- **A+ on Mozilla Observatory**: Mozilla's web security baseline: score 120 of 100, 12 of 12 tests passed. [Live result](https://developer.mozilla.org/en-US/observatory/analyze?host=cotlet.dev)
- **Clean on Sucuri SiteCheck**: No malware, spam or defacement, and not on any of 9 blocklists, Google Safe Browsing included. [Live result](https://sitecheck.sucuri.net/results/cotlet.dev)

[How Cotlet protects your access](https://cotlet.dev/security.md)

### Common concerns

**Who runs Cotlet?**

Cotlet is run by Take Group, a Polish software company working since 2019. Take Group runs about 3,200 websites on its own systems and has its own DevOps team for infrastructure security. We built and used integrations like this inside the company for years before opening them as Cotlet.

**Is this an official Google Search Console integration?**

No, Cotlet is independent of Google Search Console. Google Search Console's own API is too limited for this work. Cotlet works through your own Google Search Console account, the way you use Google Search Console in the browser, so you need no partner approval and no developer setup.

**What about client data and GDPR?**

Cotlet is run from the EU and follows the GDPR. Cloud Browsers run in Finland, a Tier 1 country in the ITU Global Cybersecurity Index 2024. Data passes through a call and is not kept after it.

**Can I start with read only?**

Yes. Enable the app for agents as read only, or make the API key read only, and anything that reaches other people waits for your OK unless you switch that off per tool.

**Is it reliable?**

Every Cotlet service is checked every 3 minutes from Europe, North America, Asia and Australia. The live results and any outage are public at status.cotlet.dev.

**How do I stop?**

Press Disable for agents next to Google Search Console in your console: your agents lose access at once and you stay signed in. Signing out of Google Search Console in the browser works too, and Reset browser deletes the whole profile.

## Is there a Google Search Console MCP server on GitHub?

Yes. Open-source Search Console MCP servers exist on GitHub, usually maintained by one person. They run on the official API, so they read stats, sitemaps and the indexed version of a URL, and you install, authorize and fix them yourself. Cotlet hosts the same kind of server for you, our team keeps it working, and its tools also do what the official API cannot: Request indexing, the live test, Page indexing lists, the Links report, removals and users.

|  | GitHub MCP server | Cotlet |
|---|---|---|
| Setup | Clone the repo, create Google Cloud credentials (OAuth or a service account), grant them access to each property, add it to each MCP client | Sign up, sign in to Google once in your Cloud Browser, add one MCP server or API key |
| What it covers | What the official API offers; Request indexing goes through the Indexing API, which Google limits to job and livestream pages | The same actions as the web interface: Request indexing, live test, Page indexing lists, Links report, removals, users |
| When Google changes the app | It breaks until you or the maintainer fix it | Our team tests it daily and fixes it for you; failed calls are free |
| Your Google access | An OAuth token or service account key in a file on your computer, readable by any program you run | Signed in inside your own Cloud Browser in the EU, profile encrypted, only for the apps you enable, disabled for agents in one click; if Google signs you out, your agent gets a link to sign in again |
| Upkeep | You update, monitor and debug it yourself | Nothing to host or update |
| Where it runs | Your computer, while it is on | Hosted: Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | Free, paid for with your time | Free 7-day trial, then pay-as-you-go credit packs, no subscription |

### Which one fits you

**Pick Cotlet if**

- you are not a developer, or you do not want to maintain a server
- you need it to keep working when Google Search Console changes, without checking it yourself
- your agent or a script should run it on a schedule, also while your computer is off

**Pick an open-source server if**

- you are comfortable installing, updating and fixing it yourself
- you want your sign-in to stay on your own computer
- you only need it now and then, from one MCP client

## How much does the Google Search Console API cost?

Free 7-day trial with 2,000 credits, no card needed. After that, the Google Search Console API is pay as you go with no limit on apps: Credit packs from $29 for 5,000 credits, one-time, no subscription. A successful call uses 20 to 30 credits (25 for most tools, about $0.10 to $0.15), your Cloud Browser uses 50 credits a day while it has an app enabled for agents, however many apps that is, and an agent driving the browser itself uses 5 credits a minute. Credit packs stay valid for 12 months and stack, so unused credits carry over.

| Credits | Price, one time | Calls at 25 credits | Per 1,000 credits |
|---|---|---|---|
| 5,000 | $29 | 200 | $5.80 |
| 15,000 | $79 | 600 | $5.27 |
| 32,000 | $149 | 1,280 | $4.66 |
| 60,000 | $249 | 2,400 | $4.15 |

Only successful calls use credits; failed calls and timeouts cost nothing. At a balance of 0 calls pause, never a surprise charge. Authenticate with the `Authorization: Bearer` header. [See full pricing](https://cotlet.dev/pricing.md)

## How Cotlet holds your access

Cotlet hosts MCP servers and REST APIs for apps with no usable API. Your agent works in your own Google Search Console account.

- **Company details:** Cotlet is run by Take Group sp. z o.o., a company registered in Poland. Its full address and registration numbers are in the Terms of service. [Terms of service](https://cotlet.dev/terms)
- **Your sign-in:** You sign in to Google Search Console yourself, in your own Cloud Browser: a Chrome we run for you in the EU, one per app. We never save your password (password saving is off), the profile is stored encrypted with AES-256-GCM, and your agents get Google Search Console only after you enable it. When Google Search Console signs you out, your agent gives you a link to sign in again. [Security](https://cotlet.dev/security.md)
- **Revoking access:** Press Disable for agents next to Google Search Console, sign out of Google Search Console in your Cloud Browser, or reset the browser. Every background request is listed in your Background activity. Actions that reach other people wait for your OK unless you switch that off per tool.
- **What we never do:** Store passwords, solve CAPTCHAs or bypass MFA.
- **Google Search Console's terms:** You use your own Google Search Console account and stay responsible for following Google Search Console's terms. Cotlet is independent and not affiliated with Google Search Console. [Terms](https://cotlet.dev/terms)
- **Contact:** Questions about the company, security or an app: [contact@cotlet.dev](mailto:contact@cotlet.dev)

## Frequently asked questions

**How do I get access?**

Sign up free, open Google Search Console in the console and press Request access. Then you create your API key and connect Google Search Console there.

**Do I need to be technical?**

No. You sign in to Google Search Console once in your Cloud Browser, a normal Chrome you open from the console, and paste one command into your agent, or one URL into n8n. Your agent can walk you through it. There is no server to install, update or fix.

**Is it safe to connect Google Search Console to Cotlet?**

Yes. You sign in to Google Search Console yourself, in your own Cloud Browser in the EU, and we never save your password. Your agents only get Google Search Console once you enable it, every background request is listed, and the browser profile is stored encrypted with AES-256-GCM, the cipher 1Password uses for its vaults. The AI model never sees a login, posts and messages wait for your OK, and Disable for agents cuts access in one click. Independent scanners grade cotlet.dev A+ on Qualys SSL Labs, securityheaders.com and Mozilla Observatory; live results are on https://cotlet.dev/security.

**Is a hosted server safer than a local one? My Google Search Console sign-in would leave my computer.**

On Cotlet you sign in inside your own Cloud Browser, which only you open, and its profile is stored encrypted with AES-256-GCM in the EU. Agents get only the apps you enable, and every background request is listed. A local server keeps your Google Search Console cookie in a plain file on your computer, readable by any program you run, and stops when your computer is off.

**Why does Cotlet send requests instead of clicking in my browser?**

To be fast, Cotlet doesn't click through Google Search Console's pages. It sends the same requests your browser would, from your browser's IP with its cookies, without opening a window. Google Search Console sees the same browser and IP you signed in with, and every request is listed in your Background activity.

**What if someone gets my Cotlet API key?**

The key holds no Google Search Console login or cookies, it only asks Cotlet to run a tool. It can call only the apps and tools you gave it, and a read-only key changes nothing. Anything that reaches other people, like posts, comments or messages, waits for your OK in the dashboard by default, so a leaked key cannot post or message as you. When you switch approval off for a scheduled job, give that job its own key limited to that one tool. Every call is in your activity log, and deleting the key ends access at once.

**Why a signed-in browser and not OAuth, like other integration platforms?**

Google Search Console offers no OAuth token you can simply grant for these tools: its official API leaves them out or needs a developer app, a plan or an approval first (see the official API section above). That is why Cotlet sets the limits itself: per key, per tool, with your approval before anything reaches other people. Cotlet is run by Take Group sp. z o.o., an EU company (VAT PL6342984273).

**Can I use the Indexing API to get normal pages indexed?**

No. Google says the Indexing API can only be used for pages with JobPosting, or BroadcastEvent embedded in a VideoObject, applies its spam policies to what you submit and tells you not to circumvent limits with multiple accounts. request_indexing presses Request indexing in the URL Inspection tool instead, which is the documented way to ask for an ordinary page.

**How many URLs can I request per day?**

About 10 a day per Google account, shared across every property the account can open; adding more properties does not raise it. Each request_indexing call spends one. When Google refuses, the call returns quota_exceeded, nothing is submitted, and your agent picks up the rest on the next run.

**Which Search Console role do I need?**

Owner or Full user permission covers every tool: performance, inspection, Request indexing, Validate fix, sitemaps, Links and Removals. Adding or removing users needs Owner, as Google allows only owners to grant permissions.

**Can my agent post or send messages in Google Search Console without asking me?**

No. Every call to request_url_removal, add_user or remove_user waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals. request_indexing, validate_fix, submit_sitemap runs without asking, because it sends nothing to anyone and one call undoes it.

**Can I use the Google Search Console API in n8n?**

Yes. Add https://cotlet.dev/mcp/v1 with your API key in n8n's MCP Client node, or call its endpoints under https://cotlet.dev/api/v1/google-search-console from the HTTP Request node.

---

Give your AI agents your signed-in browser.

**Product:** [Integrations](https://cotlet.dev/integrations.md) · [Use cases](https://cotlet.dev/use-cases.md) · [How it works](https://cotlet.dev/how-it-works.md) · [Pricing](https://cotlet.dev/pricing.md) · [Security](https://cotlet.dev/security.md)

**Resources:** [Blog](https://cotlet.dev/blog.md) · [API docs](https://cotlet.dev/docs.md) · [Help center](https://cotlet.dev/help.md) · [Changelog](https://cotlet.dev/changelog.md) · [GitHub](https://github.com/cotletdev/cotlet)

**Solutions:** [For developers](https://cotlet.dev/for-developers.md) · [For automation agencies](https://cotlet.dev/for-agencies.md)

**Company:** [About](https://cotlet.dev/about.md) · [AI info: company facts](https://cotlet.dev/ai-info.md) · [Contact](https://cotlet.dev/contact.md)

**Legal:** [Terms of service](https://cotlet.dev/terms) · [Privacy policy](https://cotlet.dev/privacy) · [Refund policy](https://cotlet.dev/refunds) · [Acceptable use](https://cotlet.dev/acceptable-use) · [Cookie policy](https://cotlet.dev/cookies) · [DPA](https://cotlet.dev/dpa) · [Subprocessors](https://cotlet.dev/subprocessors)

**Elsewhere:** [Status page](https://status.cotlet.dev) · [Cotlet on GitHub](https://github.com/cotletdev) · [Cotlet on X](https://x.com/cotletdev) · [Cotlet on LinkedIn](https://www.linkedin.com/company/cotletdev) · [Cotlet on Product Hunt](https://www.producthunt.com/products/cotlet) · [Cotlet on Crunchbase](https://www.crunchbase.com/organization/cotlet) · [Cotlet on SaaSHub](https://www.saashub.com/cotlet)

Cotlet is an independent service. It is not affiliated with, endorsed by or sponsored by any of the products listed on this site. Product names are trademarks of their respective owners.

## For AI agents: sign your user up

Is your user asking you to sign them up for Cotlet? You can do it for them, no account or key needed.

1. Read the fields and their allowed values: GET https://cotlet.dev/api/v1/access-requests
2. Ask the user for each value: email, apps, what you will do with them. If they leave the password to you, generate a strong one and show it to them.
3. Show the user what you will send, then POST it as JSON to https://cotlet.dev/api/v1/access-requests.

One call creates the account and sends the access request; we email the user when access is granted.