Stop wasting time in Search Console manually inspecting URLs. Deliver a reliable index status check directly inside your tools, dashboards, or automation pipelines using a simple REST endpoint.
You don't have time to paste URLs into a search bar. When you need to check if URL is indexed at scale, a manual approach fails. We've built a clean REST API that returns a binary indexed-not indexed status plus the last crawl date. The endpoint authenticates via Bearer token, enforces sane rate limits, and returns JSON in under 200 milliseconds for cached URLs. No scraping. No headless browser. No fluff.
A common situation we see: an agency managing 50 client sites runs a weekly audit. They export 10,000 URLs from a sitemap, feed them through the API, and flag every URL that returns a non-indexed status. That single automation saves 12 hours of manual lookup per week. The Google Indexing API quickstart is the authority reference for the underlying protocol, but our wrapper handles authentication, retries, and error normalization so you don't have to.
| Criterion | Raw Google Indexing API | Our Wrapper API | Verdict / Risk |
|---|---|---|---|
| Authentication Setup effort | OAuth 2.0 service account Scope: https://www.googleapis.com/auth/indexing | Single Bearer token Header: Authorization: Bearer | Wrapper wins on onboarding speed. Risk: token rotation must be automated. |
| Rate Limits Per project per day | 200 URL notifications per day Batch limit: 1 per request | 100 requests per minute No daily cap for queries | Wrapper better for bulk checking. Risk: hitting 100/min blocks for 60s. |
| Response Format Data structure | JSON with urlNotificationMetadata Requires parsing nested objects | {'indexed': true/false, 'last_crawled': 'ISO timestamp', 'error': null} | Wrapper clearer for devs. Risk: missing metadata fields for deep debugging. |
| Error Handling Common failures | 403: quotaExceeded 500: backendError No retry logic | 429: rateLimited (auto-retry after 1s) 503: serviceUnavailable (retry 3x) Custom error codes | Wrapper reduces operational failures. Risk: consecutive retries may still fail under severe backend load. |
Extract from sitemap, CMS export, or crawl log. Deduplicate. Limit to 10,000 per batch.
Send POST to /auth with API key. Receive Bearer token (expires 1 hour). Store in memory.
POST /check-index with JSON array of up to 500 URLs. Include token in header.
Each returned object includes indexed (bool), last_crawled (ISO), and error (string or null).
Re-queue 429 or 503 failures. Log 400 errors (malformed URL) for manual review.
Generate CSV of non-indexed URLs. Trigger email or Slack alert if non-indexed rate > 5%.
You manage a 50,000-page e-commerce site. You export 5,000 product URLs from the sitemap. Using the API, you split them into ten 500-URL batches. You set a concurrency of 3 to stay under the 100 req/min limit. After 4 minutes, you get results: 4,820 indexed (96.4%), 180 non-indexed (3.6%). Among the non-indexed, 22 return a 400 error (malformed URL: double-encoded ampersand). You fix those, re-submit via sitemap. The remaining 158 are legitimate non-indexed pages: you push them to the fix crawl budget waste guide to prioritize indexing for high-value pages.
Real edge: 3 URLs timed out. You retry them individually after 30 seconds. Two succeed on retry (indexed). One permanently fails with 503. You log it and check server health.
You send a URL that returns 'indexed: false' but the page is live and has been submitted three times. What gives? The URL might be blocked by robots.txt, even though the index status check doesn't validate that. We've seen cases where a noindex meta tag causes false negatives — the API correctly returns non-indexed, but the developer blames the API. Another failure: duplicate lists. One client fed 50,000 URLs with 30% duplicates. The API counted duplicates against rate limits. Deduplicate client-side before sending.
Empty results happen when the backend has never crawled a fresh URL. Our API returns 'indexed: false' with last_crawled: null. That's not an error — it's a signal to prioritize that URL. Weak pages (thin content, low word count) often show as indexed but with a 'last_crawled' date months old. Google doesn't recrawl them often. Use the index coverage report to cross-reference crawl frequency against content quality. Slow vendor? One user saw 2-second response times during Google's backend degradation. We added a 5-second timeout and automatic failover to a secondary data source.
You get one API key per agency account. Inside each request, you can pass a client_id parameter. The API then uses the client-specific Google service account credentials (which you configure once in the dashboard). This avoids key sprawl while keeping billing separate.
The endpoint accepts up to 500 URLs per POST request. For larger lists, split into batches of 500 and stagger requests at least 1 second apart to stay under the 100 req/min rate limit. We recommend 10 parallel batches max to avoid triggering 429 errors.
This happens when Google has the URL in the index but the page is set to 'noindex' via meta tag or HTTP header. The API checks the official index status, not the cached search result. Verify the page source for noindex directives. Also check robots.txt for disallow rules.
Handle 400 (malformed URL or invalid JSON), 401 (bad or expired token), 429 (rate limit exceeded - retry after 60s), 503 (backend unavailable - retry up to 3 times with 5s backoff), and 200 with error field 'internal_error' (retry once). Log all 400s for manual URL cleaning.
Add a build step that reads the guest post URLs from a file, calls the API, and fails the build if any URL returns indexed: false. Use the exit code 1 to block deployment. Set a threshold: allow up to 2% non-indexed URLs to tolerate new posts not yet crawled. Notify the team via Slack on failure.
We offer 1,000 free API calls per month for testing. Paid tiers start at $29/month for 25,000 calls. Enterprise plans with dedicated rate limits and SLA start at $199/month. All plans include OAuth token management and retry logic. No hidden overage fees — you get hard caps.
No. The API checks Google's public index. Private URLs (login-required, staging subdomains blocked by robots.txt) will always return indexed: false. For staging, use a different approach: deploy the page to a public test domain and check that. The API only works for publicly accessible pages.
Slow responses usually indicate a cold cache for that URL. The first request for a URL takes ~2 seconds as we query Google's backend. Subsequent requests for the same URL return in <200ms. For a list of 500 backlinks, expect the first batch to be slow. Pre-warm by sending a single request per URL 24 hours before your main check.
First, double-check the URL format (trailing slash, protocol). If still empty, use the Google Search Console URL Inspection API as a fallback. Our wrapper automatically falls back to a secondary source if the primary returns empty. You can also manually verify using the URL Inspection Tool in Search Console for a single URL.
Yes: 1) Whitelist server IP. 2) Rotate API key every 90 days. 3) Implement retry with exponential backoff for 503. 4) Set dashboard alert for >5% non-indexed rate. 5) Log all 400 errors to a separate file. 6) Monitor response times; alert if p95 > 2s. 7) Test with 10,000 URLs before going live.
Quick calculator. Put in the expected monthly value of a page or link batch and the natural waiting time.