---
name: google-search-console
description: Submit a site to Google Search Console — verify/select the property, submit sitemap.xml, and request indexing for priority URLs — by driving a logged-in browser. Use when the user asks to "submit to Google", "submit the sitemap", "request indexing", "get pages indexed", "set up Search Console", "why isn't my site on Google", or wants a site/blog to start appearing in Google search. Do NOT use for Bing-only submission (note IndexNow below), for on-page SEO/content edits, or for querying existing ranking data (use a search/analytics tool).
compatibility: Requires a browser-control CLI/tool (thinkrun/thinkbrowse local mode, Playwright, or equivalent) with navigate + native type/press/click + screenshot. The user must complete Google sign-in themselves (OAuth is a human handoff). Optional mech-search (Serper) for index-coverage verification.
metadata:
  author: mech-browse
  version: 1.0.0
---

# Google Search Console Submission

Get a site discovered and indexed by Google: submit its sitemap, then optionally request priority indexing for key pages. The **sitemap submission is the primary win** — it makes Google discover every URL in the sitemap. Per-page "Request Indexing" is only an accelerator for a few priority pages.

Reachable ≠ indexed. A page can be crawlable (200 + in sitemap + allowed by robots) yet absent from Google for days-to-weeks until crawled. Submitting the sitemap and requesting indexing shortens that.

## Prerequisites (verify before touching GSC)

Confirm the technical SEO is submittable first — otherwise submission is wasted:

1. `curl -s -A Mozilla/5.0 https://<domain>/sitemap.xml` → 200, and `<loc>` entries list the URLs you expect.
2. `curl -s -A Mozilla/5.0 https://<domain>/robots.txt` → allows crawl (`Allow: /` or no blocking `Disallow`) **and** declares `Sitemap: https://<domain>/sitemap.xml`.
3. Spot-check a key page for `Googlebot`: `curl -s -A "Googlebot/2.1" https://<domain>/<path>` → 200 with real prerendered content (not an empty SPA shell).

If any fail, fix those first — the sitemap won't help pages Google can't crawl.

## Step 1: Sign in (human handoff)

Navigate the browser to `https://search.google.com/search-console/`. If it lands on the marketing `/about` page or an `accounts.google.com/...signin` URL, the browser isn't authenticated. **You cannot enter Google credentials** — OAuth/password is a human-only step. Ask the user to complete sign-in in that browser window, then continue. Re-check `location.href` — you want a `search.google.com/.../search-console/...` URL, not `accounts.google.com`.

## Step 2: Open the property's Sitemaps page

Go directly to the Sitemaps page for the domain property:

```
https://search.google.com/u/1/search-console/sitemaps?resource_id=sc-domain:<domain>
```

(`sc-domain:` is a **domain property** covering all subdomains/protocols. If the site uses a URL-prefix property instead, the `resource_id` is the full origin, e.g. `https://<domain>/`.) A `title` of "Sitemaps" and a visible "Add a new sitemap" card confirm you're in. If it redirects to sign-in, return to Step 1. If the property doesn't exist, it must be added + verified first (domain properties verify via a DNS TXT record — drive that in the DNS provider if you control it).

## Step 3: Submit the sitemap

The "Add a new sitemap" field is an **Angular Material input** — often no stable `placeholder`/`type`, and the SUBMIT control is a Material **`div[role=button]`** (class starts `U26fgb`), **not** a `<button>`. So a plain selector click won't find it.

Use the bundled helper, which fills the field via the native value setter (Angular needs the `input` event) and clicks the Material SUBMIT div by text:

```
<browser> evaluate "$(cat scripts/submit-sitemap.js)"   # after setting the sitemap URL in the script, or pass it inline
```

Or inline (single line — many browser CLIs suppress the return value of IIFEs, so don't depend on the returned string; verify by screenshot):

```js
(function(){var url='https://<domain>/sitemap.xml';
var inps=[].slice.call(document.querySelectorAll('input')).filter(function(i){var r=i.getBoundingClientRect();return i.offsetParent!==null&&r.top>180&&r.top<520&&r.width>200;});
if(!inps.length)return 'NO_INPUT';var el=inps[0];
var set=Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype,'value').set;
set.call(el,url);el.dispatchEvent(new Event('input',{bubbles:true}));el.dispatchEvent(new Event('change',{bubbles:true}));
var btn=[].slice.call(document.querySelectorAll('div[role=button],button')).find(function(e){return /^submit$/i.test((e.textContent||'').trim())&&e.offsetParent!==null;});
if(btn)btn.click();return 'SUBMITTED';})()
```

**Verify by screenshot**, not by return value. Success = green **"Sitemap submitted successfully"** dialog. Then the "Submitted sitemaps" table shows the row with **Status = Success** and a **Discovered pages** count (Google often reads it within minutes). That count = pages Google now knows about. Dismiss the dialog (click the "Dismiss" link).

At this point the job is substantially done — every sitemap URL is queued for crawl.

## Step 4 (optional): Request Indexing for priority pages

Only worth it for a handful of high-value pages (new blog post, launch page). There is a **~10/day quota**, and the sitemap already covers everything.

**The wall:** GSC's top "Inspect any URL" bar only honors a **real, trusted Enter keypress**. Synthetic `dispatchEvent(new KeyboardEvent('keydown',{key:'Enter'}))` has `isTrusted=false` and GSC **ignores it** — the inspected URL won't change, and you'll silently keep seeing the previous page's result. The inspection deep-link (`…/search-console/inspect?resource_id=…&id=<url>`) returns a Google **404** — don't use it.

Use the browser tool's **native** keystroke commands (real CDP input), not `evaluate`:

1. Click the top search bar (native `click`/`click-at`), or focus it.
2. `type` the full URL (native typing).
3. `press Enter` (native — this is the trusted keypress GSC requires).
4. Wait ~15-25s for GSC to inspect; screenshot. Expect "URL is not on Google" + "Discovered - currently not indexed" (Discovery source will be your sitemap).
5. Click **REQUEST INDEXING**, wait ~60s for the live test; screenshot. Success = green **"Indexing requested — added to a priority crawl queue."**

**Always verify the inspected URL matches your target** (read the breadcrumb URL under the search bar via screenshot) before clicking Request Indexing — a failed Enter leaves the previous page loaded, and you'd re-request the wrong URL.

## Step 5: Verify index coverage (recurring)

Submission ≠ indexed. Check with `site:` queries (Serper via mech-search, or any search tool):

```
site:<domain>                    # total indexed pages
site:<domain>/blog               # is the blog indexed?
site:<domain>/<path-to-key-page> # is a specific page indexed?
```

`totalResults: 0` = not indexed yet. New domains/pages commonly take days-to-weeks. Fold this into a daily/weekly check so you notice when pages actually enter the index — that's when organic search referral traffic can begin.

## Bing / other engines (future extension)

This skill covers Google. For Bing, use **Bing Webmaster Tools** (similar submit-sitemap flow) — and for programmatic, quota-free submission to Bing + Yandex, set up **IndexNow**: host a `<key>.txt` at the site root and POST changed URLs to `https://api.indexnow.org/indexnow`. IndexNow needs no browser and no login, so prefer it for automation once a key is provisioned.

## Troubleshooting

- **Lands on `/about` or `accounts.google.com`** → not signed in. Human must complete Google login (Step 1).
- **SUBMIT does nothing / can't find the button** → it's a `div[role=button]`, not `<button>`; match by text `SUBMIT`. The input is Material — set `.value` via the native setter and dispatch `input`, don't just assign `.value`.
- **Request Indexing keeps hitting the same page** → your Enter wasn't trusted. Use native `press Enter`, and verify the breadcrumb URL before requesting.
- **"Discovered - currently not indexed" persists for weeks** → normal for low-authority new domains; ensure internal links + real content; the sitemap + a couple of Request-Indexing nudges are all you can do from GSC.
- **evaluate returns no value** → some browser CLIs only return the value of a bare expression, not an IIFE with side-effects. Verify state by screenshot or a follow-up bare-expression read, not the fill/click call's return.

## References

Real run (2026-07-01): submitted `https://thinkrun.ai/sitemap.xml` → **Success, 19 pages discovered** within minutes; requested indexing for one blog post ("added to priority crawl queue"). Per-page requests for the remaining pages were left to the sitemap crawl after hitting the trusted-Enter wall.