Submit URL to Google: Indexing API, IndexNow, and What Actually Works

You published a new page. You want it in Google's index. The question is: how do you tell Google it exists, and how fast will it actually get indexed?

There are three mechanisms for notifying search engines about new or updated URLs: sitemaps (passive), the Google Indexing API (active, limited), and IndexNow (active, broad). Each has trade-offs in speed, reliability, scope, and implementation complexity.

This guide covers all three with honest assessments. No "just submit your sitemap and wait" hand-waving. If you need a page indexed fast, you need to understand what actually works and what's marketing.

The Three Submission Methods#

Sitemaps: The Foundation#

Every site should have a sitemap. It's the baseline that makes everything else work better.

How Sitemaps Work#

An XML sitemap lists your URLs with optional metadata (last modified date, change frequency, priority). Search engines discover your sitemap through robots.txt or direct submission in their webmaster tools.

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://example.com/blog/new-post</loc>
    <lastmod>2026-04-05</lastmod>
    <changefreq>monthly</changefreq>
    <priority>0.8</priority>
  </url>
</urlset>

Dynamic Sitemaps in Next.js#

If you're using Next.js App Router, generate your sitemap dynamically:

// app/sitemap.ts
import { MetadataRoute } from 'next';
 
export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  // Fetch all published blog posts from your CMS or database
  const posts = await getPublishedPosts();
 
  const blogUrls = posts.map(post => ({
    url: `https://example.com/blog/${post.slug}`,
    lastModified: new Date(post.updatedAt),
    changeFrequency: 'monthly' as const,
    priority: 0.7
  }));
 
  const staticPages = [
    { url: 'https://example.com', lastModified: new Date(), priority: 1.0 },
    { url: 'https://example.com/pricing', lastModified: new Date(), priority: 0.9 },
    { url: 'https://example.com/docs', lastModified: new Date(), priority: 0.8 },
  ];
 
  return [...staticPages, ...blogUrls];
}

Sitemap Limitations#

Sitemaps are a hint, not a directive. Google is not obligated to crawl URLs in your sitemap, and having a URL in your sitemap doesn't guarantee indexing. Sitemaps help Google discover URLs more efficiently, but the decision to crawl and index is still based on Google's assessment of quality and crawl budget.

Time to crawl after sitemap update: Minutes to weeks, depending on your site's crawl frequency. High-authority sites see sitemap changes processed within hours. New or low-authority sites may wait days.

Google Indexing API: Fast but Limited#

The Google Indexing API was designed for job posting and livestream content. Google explicitly states this in their documentation. However, many developers use it for general content — with mixed results.

What the Indexing API Does#

You send a URL to Google with a notification type (URL_UPDATED or URL_DELETED), and Google adds it to a priority crawl queue.

import { google } from 'googleapis';
 
const auth = new google.auth.GoogleAuth({
  keyFile: './service-account.json',
  scopes: ['https://www.googleapis.com/auth/indexing']
});
 
const indexing = google.indexing({ version: 'v3', auth });
 
async function notifyGoogle(url: string) {
  const response = await indexing.urlNotifications.publish({
    requestBody: {
      url,
      type: 'URL_UPDATED'
    }
  });
 
  return response.data;
  // { urlNotificationMetadata: { url, latestUpdate: { type, notifyTime } } }
}

Setup Requirements#

The Honest Assessment#

Rate limits: 200 URL notifications per day. Batch requests can submit up to 100 URLs per call, but the daily limit still applies.

Speed: For job postings, indexing typically happens within minutes. For other content types, it ranges from hours to days — sometimes no faster than a sitemap update.

Risk: Using the API for non-supported content types doesn't violate any TOS, but Google could tighten enforcement at any time. Don't build a critical workflow that depends on this working for blog posts.

IndexNow: The Open Alternative#

IndexNow is an open protocol supported by Bing, Yandex, Seznam.cz, Naver, and Yep. Google does not participate.

How IndexNow Works#

You generate a key, host it as a text file on your site, and send HTTP POST requests to notify engines about URL changes.

// Generate a key (any UUID-like string works)
const INDEXNOW_KEY = 'a1b2c3d4e5f6g7h8';
 
// Host the key file at: https://example.com/a1b2c3d4e5f6g7h8.txt
// The file should contain just the key: a1b2c3d4e5f6g7h8
 
async function submitToIndexNow(urls: string[]) {
  const response = await fetch('https://api.indexnow.org/indexnow', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      host: 'example.com',
      key: INDEXNOW_KEY,
      keyLocation: `https://example.com/${INDEXNOW_KEY}.txt`,
      urlList: urls // up to 10,000 URLs per request
    })
  });
 
  return response.status; // 200 = accepted, 202 = accepted (async)
}

IndexNow in Next.js#

Create an API route that fires IndexNow on publish:

// app/api/indexnow/route.ts
import { NextRequest, NextResponse } from 'next/server';
 
const INDEXNOW_KEY = process.env.INDEXNOW_KEY!;
const SITE_HOST = 'example.com';
 
export async function POST(request: NextRequest) {
  const { urls } = await request.json();
 
  if (!urls?.length) {
    return NextResponse.json({ error: 'No URLs provided' }, { status: 400 });
  }
 
  const response = await fetch('https://api.indexnow.org/indexnow', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      host: SITE_HOST,
      key: INDEXNOW_KEY,
      keyLocation: `https://${SITE_HOST}/${INDEXNOW_KEY}.txt`,
      urlList: urls
    })
  });
 
  return NextResponse.json({
    status: response.status,
    submitted: urls.length,
    message: response.status === 200 ? 'Accepted' : 'Queued'
  });
}

IndexNow Advantages#

• No rate limits for practical purposes (10,000 URLs per request)
• Multi-engine — One submission notifies all participating engines
• Free — No API costs, no OAuth setup
• Simple — Just an HTTP POST with a key file for verification

IndexNow Limitations#

• Google doesn't support it. This is the biggest limitation. If Google is your primary traffic source, IndexNow doesn't help with Google indexing.
• Bing's market share is ~3% in most markets. IndexNow is valuable for Bing SEO, but the traffic impact is smaller than Google.
• No feedback — IndexNow returns 200 (accepted) but doesn't tell you if the URL was actually crawled or indexed.

URL Inspection: The Manual Override#

For individual URLs, the URL Inspection tool in Google Search Console remains the most reliable way to request indexing from Google.

1. Open Search Console for your property
2. Enter the URL in the inspection bar at the top
3. Wait for the live test to complete
4. Click "Request Indexing"

Speed: Typically processed within 24-48 hours. Sometimes faster for high-authority sites.

Limit: Approximately 10 requests per day per property. This is a manual tool, not a programmatic one (though the URL Inspection API exists for checking status — it does not support requesting indexing).

Honest Speed Comparison#

Based on real-world testing across sites of varying authority:

The takeaway: There's no instant indexing for Google. The fastest reliable path is a combination of an up-to-date sitemap, URL Inspection for priority pages, and patience. For Bing and other engines, IndexNow is dramatically faster.

The Optimal Submission Strategy#

For most sites, the right approach is layered:

Automating Submission with Rampify#

Instead of building and maintaining separate integrations for sitemaps, IndexNow, and indexing monitoring, Rampify handles the pipeline:

# In your AI coding tool (Claude Code, Cursor, Windsurf)
 
"I just published a new blog post at /blog/google-indexing-guide. 
 Make sure it's set up for indexing."
 
# AI calls get_page_seo() to verify:
# - Meta tags are present and optimized
# - Canonical URL is correct
# - Page is not accidentally noindexed
# - JSON-LD schema is valid
# - Internal links exist from other pages
# - Page is in the sitemap
 
# AI calls get_issues() to check for problems:
# - Missing meta description
# - Duplicate title tag
# - Broken internal links
# - Missing alt text on images
 
# If issues are found, AI creates a spec with fixes

The key insight: submission is only half the problem. The other half is making sure the page is actually worth indexing before you submit it. A technically perfect submission of a page with missing meta tags, no internal links, and thin content is still going to result in "Crawled - currently not indexed."

Rampify's approach combines submission awareness with content quality checks, so you catch problems before Google does.

For more on monitoring indexing status programmatically, see our GSC API guide. For fixing pages that were crawled but not indexed, see the dedicated troubleshooting guide.