IndexNow: Get your content indexed instantly by AI search engines and traditional search

If you’re still waiting days or weeks for search engines to discover your new content, you’re missing out on one of the web’s best-kept secrets: IndexNow

IndexNow is a protocol that lets you instantly notify search engines when your content changes. Instead of waiting for crawlers to stumble upon your updates, you proactively tell them “hey, I just published something new!” The beauty of IndexNow is its simplicity: submit a URL once, and all participating search engines including Microsoft Bing, DuckDuckGo, and others get notified automatically. Think of it as a notification system for the web.

Google doesn’t support IndexNow yet, so for Google you’ll still rely on traditional XML sitemaps and their own indexing API. But for the rest of the search ecosystem, IndexNow is a game changer.

Traditional search engine crawling is inefficient. Search engines waste resources crawling unchanged pages while your new content sits undiscovered for days or weeks, and you have no control over when crawlers visit your site. With IndexNow, new content gets indexed in hours (sometimes minutes), search engines only crawl what actually changed, you control when to notify search engines, and it’s completely free and easy to implement.

The workflow is straightforward. You generate an API key which is just a random string, host a verification file at your domain root, submit URLs to IndexNow API when content changes, and IndexNow shares your submission with all partner search engines. No OAuth flows, no complicated authentication, no rate limits to worry about within reason.

Setting Up IndexNow

This guide includes implementation examples for multiple frameworks and platforms. Click on your technology below to jump directly to its implementation guide:

Generating Your IndexNow API Key

The first step in setting up IndexNow is generating your API key. This key proves to search engines that you own the domain and authorizes your IndexNow submissions.

Your API key should be a random hexadecimal string between 8-128 characters. The simplest way to generate one is using openssl:

This generates something like 19942de05a08448b2f69abd9cfa9f9b8. Save this key because you’ll need it for all IndexNow submissions.

Next, create a text file named exactly after your API key with a .txt extension in your public directory. This file proves to search engines that you own the domain:

The file must be named exactly as your API key, located at your domain root so it’s accessible at https://yourdomain.com/[key].txt, and contain only the API key with no extra whitespace or characters. After deployment, verify it’s accessible:

You should see your API key returned with no extra formatting.

API Key Security Best Practices

The IndexNow API key sits in an unusual security position. Anyone can discover it by visiting https://yourdomain.com/[key].txt because search engines need to verify domain ownership. Yet you should still protect how your application uses this key. If someone gets hold of it and uses it in their own code, they could submit URLs on your behalf, trigger rate limiting with excessive submissions, or worse, submit malicious URLs that damage your domain’s reputation with search engines. They could also track exactly when and what you’re submitting.

Version Control

Never commit API keys to Git. Add .env to your .gitignore file and use .env.example with placeholder values for documentation. The verification file (your-key.txt) in the public directory is fine to commit since it needs to be publicly accessible anyway.

Environment Variables

Store your key as INDEXNOW_API_KEY in your .env file locally. Add it to your hosting platform’s environment variables (Vercel, Netlify, whatever you’re using). Never hardcode the key directly in your source code, even though it’s technically public. The point isn’t to hide the key itself but to control who can use it in your application.

Endpoint Protection

Add authentication to your IndexNow submission endpoints using API keys, OAuth, or JWT. Implement rate limiting to prevent abuse. Validate incoming requests and sanitize URLs before submitting them. Log all submissions so you can audit what went through and when.

Monitoring

Watch for unexpected submission patterns. Set up alerts for rate limit errors. Review your IndexNow submission logs regularly. If something looks off, rotate your API key immediately.

Authentication Example

Key Rotation

If you suspect your IndexNow API key has been compromised, generate a new one using openssl rand -hex 16. Update the verification file in your public directory. Update INDEXNOW_API_KEY in all your environments (local, staging, production). Redeploy your application. Wait 24-48 hours before deleting the old verification file so search engines have time to update their records.

Treat your IndexNow API key like a password: keep it in environment variables, never commit it to source code, protect your endpoints with authentication, and watch for suspicious activity. The key itself must be publicly accessible via the verification file, but controlling who can use it in your application prevents abuse.

Now that you have your API key set up securely, choose your framework or technology from the table above to see the specific implementation guide.

Astro Implementation

Astro’s integration system allows you to hook into the build process and automatically submit URLs to IndexNow every time you deploy. Unlike manual submissions or client-side approaches, this method ensures complete coverage of your site by reading the generated sitemap and submitting all URLs without any intervention.

The integration works by tapping into Astro’s astro:build:done hook, which fires after the build completes and all static files including your sitemap have been generated. This is the perfect timing to read your sitemap, extract all URLs, and submit them to IndexNow in a single batch operation.

This approach works well for content-heavy sites where you want guaranteed indexing of every page. Whether you’re deploying to Vercel, Netlify, or any other platform, the integration runs automatically as part of your build process, so you never have to remember to manually submit URLs.

Before implementing, make sure you’ve generated your IndexNow API key using the instructions in the Generating Your IndexNow API Key section above.

First, create a utility file to handle IndexNow submissions:

This utility provides three functions: submitToIndexNow for submitting multiple URLs, submitSingleUrl for convenience when submitting one URL, and submitInBatches for handling large URL lists with automatic chunking and rate limit protection.

Next, create an API endpoint for manual URL submissions:

This endpoint allows you to manually submit URLs by making POST requests to /api/indexnow. The GET endpoint provides a status check showing whether your API key is configured.

Finally, create the Astro integration plugin for automatic submission:

The integration function returns an Astro integration object with a name and hooks property. The hook function receives the build output directory, which it uses to locate the generated sitemap file. It then validates the API key exists, reads the sitemap XML, extracts all URLs using regex matching, and submits them in batches using the utility function we created earlier.

The configuration object accepts enabled and verbose flags for controlling behavior, plus an optional apiKey that falls back to environment variables. This flexibility lets you disable submissions in development or customize logging based on your deployment environment.

Now register the integration in your Astro configuration:

With this configuration in place, every time you run npm run build or yarn build, the integration will automatically read your sitemap and submit all URLs to IndexNow. You’ll see console output showing how many URLs were found and whether the submission succeeded, giving you immediate feedback during deployment.

The integration handles errors gracefully by catching and logging them without breaking your build process. If the sitemap doesn’t exist or the API key isn’t set, it will log a warning and continue, ensuring your builds don’t fail due to IndexNow issues.

React Implementation

React applications can integrate IndexNow through custom hooks that trigger submissions when content changes. The key is to create a reusable hook that handles the API call and manages the submission state. This approach works well for client-side rendered React apps, React with server-side rendering, or Create React App setups.

The hook pattern makes it easy to trigger IndexNow submissions from anywhere in your component tree. You can call it when publishing new blog posts, updating pages, or whenever content changes that should be indexed. The hook accepts a URL and a boolean flag that determines whether to submit, giving you full control over when submissions happen.

Start by creating the custom hook:

This hook uses the useEffect dependency array to automatically trigger submissions when either the URL or the shouldSubmit flag changes. The early return prevents unnecessary API calls when shouldSubmit is false.

Now use it in your components when publishing new content:

The justPublished prop would be set to true immediately after creating or updating content, triggering the IndexNow submission. You might set this based on query parameters, state management, or after a successful save operation. For example, if you’re using React Query or Redux, you could trigger the submission after a successful mutation or action.

Next.js Implementation

Next.js applications benefit from IndexNow integration at multiple levels including API routes, server actions, and the app router. The framework’s hybrid nature means you can handle IndexNow submissions both server-side and client-side depending on your needs.

For API routes in the pages directory, create an endpoint that accepts URL submissions:

This API route handles POST requests and validates the request method before processing. It extracts URLs from the request body and passes them to the IndexNow utility function along with your API key from environment variables. The response includes the full result object so clients can handle errors appropriately.

For Next.js 13+ with the app router, you can use route handlers instead. Create a file at app/api/indexnow/route.ts with similar logic but using the new Route Handler API. Server Actions are another option where you can directly call IndexNow from server components without needing a separate API endpoint.

You can also integrate IndexNow into your build process using next.config.js. Add a plugin that reads your sitemap after build and automatically submits all URLs, similar to the Astro integration shown earlier.

Vue Implementation

Vue 3 applications work best with composables that follow the Composition API pattern. The composable approach provides reactive integration with Vue’s reactivity system, making it easy to trigger IndexNow submissions based on component state changes.

Create a composable that watches for changes and submits URLs:

The composable uses Vue’s watch function to observe the shouldSubmit ref. When it becomes true, the composable triggers an async fetch to your IndexNow API endpoint. This pattern integrates with Vue’s reactivity, so any state change that sets shouldSubmit to true will automatically trigger a submission.

In your Vue components, you can use the composable like this with reactive refs. Import the composable, create refs for your URL and submission flag, and the composable will handle the rest. For example, in a blog editor component, you might set shouldSubmit to true after successfully saving a post to your database.

The beauty of this approach is that it’s completely reactive and composable. You can combine it with other Vue composables like useFetch or useAsyncData to create a complete content publishing workflow that automatically notifies search engines when new content goes live.

Nuxt Implementation

Nuxt provides a server API that makes IndexNow integration straightforward. With Nuxt’s file-based routing for API endpoints, you can create server routes that handle IndexNow submissions with minimal configuration.

Create a server API endpoint using Nuxt’s conventions:

Nuxt’s defineEventHandler wraps your endpoint logic and provides type-safe access to the request through readBody. The .post.ts suffix in the filename automatically restricts this endpoint to POST requests only, eliminating the need for manual method checking.

The endpoint imports your IndexNow utility function and environment variables are automatically available through process.env. Since this runs on the server, you have direct access to all Node.js APIs and can safely use sensitive API keys without exposing them to the client.

From the client side, you can call this endpoint using Nuxt’s $fetch utility or the standard Fetch API. The integration works with Nuxt’s server-side rendering, meaning you can trigger IndexNow submissions during SSR, static generation, or client-side navigation.

For automatic submissions during build, you can create a Nuxt module that hooks into the build process. This module would read your sitemap after generation and submit all URLs to IndexNow, ensuring every page gets indexed whenever you deploy.

Vanilla JavaScript Implementation

For websites built without frameworks or static sites that just need JavaScript, you can implement IndexNow with a simple standalone function. This approach works for any website that can make HTTP requests, whether it’s a traditional multi-page application, a static site, or even a WordPress theme.

Here’s a complete implementation that works anywhere:

This vanilla implementation handles everything in a single function. It constructs the payload according to IndexNow specifications, makes the POST request directly to the IndexNow API endpoint, and handles both success and error cases.

The function is completely self-contained with no dependencies, making it perfect for adding to existing sites without any build process. You can include it in a script tag, bundle it with your existing JavaScript, or even inline it directly in your HTML.

The key difference from the framework approaches is that you’re hitting the IndexNow API directly rather than going through your own backend endpoint. This means your API key is exposed in the client code, which is fine for IndexNow since the key is already public in your verification file. However, if you want to keep submission logic server-side, you could modify this to call your own API endpoint instead, similar to the framework examples.

You can trigger this function from anywhere, like after a form submission, when content loads dynamically, or even attach it to click events on publish buttons in a content management system.

SvelteKit Implementation

SvelteKit’s server-side routing makes IndexNow integration remarkably straightforward with its file-based API routes. The framework’s convention-over-configuration approach means you can create endpoints with minimal boilerplate, and the built-in request handling gives you everything needed to process IndexNow submissions securely on the server.

Create a server route for handling IndexNow submissions:

The +server.ts naming convention tells SvelteKit this is a server-only route that won’t be included in client bundles. Environment variables use the $env/static/private module, ensuring your API key stays server-side. For client-side usage, create a Svelte store that manages submission state, and the reactive system automatically updates your UI based on submission status.

Angular Implementation

Angular’s dependency injection system and service-based architecture make it ideal for creating reusable IndexNow integration. Create a dedicated service for handling submissions, inject it wherever needed, and maintain clean, testable code throughout your application.

The service uses Angular’s inject() function for dependency injection, and providedIn: 'root' makes it a singleton available throughout your application. RxJS operators like tap and catchError provide clean error handling. Inject the service in components and call its methods when publishing content, with observables handling async operations.

Laravel Implementation

Laravel’s elegant routing and controller system make IndexNow integration straightforward with its expressive syntax. The framework’s built-in HTTP client and response helpers provide everything needed to create clean, maintainable IndexNow endpoints that feel natural within the Laravel ecosystem.

Laravel’s service container and dependency injection make it easy to create reusable IndexNow services that can be injected anywhere in your application. Whether you’re building a REST API, a traditional web app, or a headless CMS, Laravel’s flexibility ensures IndexNow integration fits into your architecture.

Create a controller to handle IndexNow submissions:

Register the route in your routes file:

Add your IndexNow API key to the config. Laravel’s configuration system keeps sensitive data in environment variables:

Laravel’s validator ensures URLs are properly formatted before submission. The built-in HTTP client handles the IndexNow API call with clean, readable syntax. Response helpers like response()->json() make it easy to return properly formatted JSON responses with appropriate status codes.

Ruby on Rails Implementation

Ruby on Rails brings convention over configuration to IndexNow integration, making it simple to create clean, RESTful endpoints. The framework’s emphasis on developer happiness means you can build IndexNow functionality with minimal boilerplate code.

Rails’ built-in HTTP client and strong parameters make handling IndexNow submissions secure and straightforward. The framework’s MVC architecture naturally separates concerns, allowing you to organize your IndexNow logic in a way that’s maintainable and testable.

Create a controller to handle IndexNow submissions:

Add the route to your routes file:

Rails’ strong parameters and built-in request/response handling make the controller code clean and secure. The skip_before_action :verify_authenticity_token is necessary for API endpoints that accept JSON from external sources. For production use, you’d want to add proper authentication or rate limiting middleware.

Add the http gem to your Gemfile for making HTTP requests, or use Rails’ built-in Net::HTTP if you prefer no additional dependencies. The controller automatically handles JSON parsing from the request body and renders JSON responses with appropriate HTTP status codes.

Django Implementation

Django’s clean, pragmatic design makes IndexNow integration straightforward with its view system and JsonResponse class. The framework’s “batteries included” philosophy means you have everything needed for handling HTTP requests and JSON responses built right in.

Django views can be either function-based or class-based, but for API endpoints like IndexNow, function-based views are often simpler and more direct. The framework’s URL routing system makes it easy to map specific paths to view functions, and the JsonResponse class handles all the details of creating properly formatted JSON responses with correct content-type headers.

Before implementing this endpoint, make sure you’ve generated your IndexNow API key using openssl rand -hex 16 as described earlier in this guide. You’ll also need to create the verification file at public/YOUR_API_KEY.txt containing your key.

Create a Django view to handle IndexNow submissions:

Register the URL pattern in your Django URLconf:

The @csrf_exempt decorator is necessary for API endpoints that accept JSON from external sources, as Django’s CSRF protection expects form-encoded data. The @require_http_methods decorator ensures only POST requests are accepted. Django’s request.get_host() automatically extracts the domain from the incoming request, and JsonResponse handles serialization with proper headers.

Flask Implementation

Flask’s minimalist design and flexibility make it perfect for creating lightweight IndexNow endpoints. The framework’s simplicity means you can create a working API endpoint in just a few lines of code, yet it can handle production workloads.

Flask’s routing decorator syntax is clean and intuitive, making it obvious which functions handle which URLs. The jsonify function automatically serializes Python dictionaries to JSON with the correct content-type headers, and request.get_json() handles parsing incoming JSON payloads with proper error handling.

Before implementing this endpoint, make sure you’ve generated your IndexNow API key using openssl rand -hex 16 as described earlier in this guide. You’ll also need to create the verification file at public/YOUR_API_KEY.txt containing your key.

Create a Flask route for IndexNow submissions:

Flask’s tuple return syntax allows you to return both the response body and status code in one clean line. The request.get_json() method automatically handles JSON parsing and returns None if the content-type is wrong or the JSON is malformed, making error handling straightforward. This pattern works whether you’re deploying to a traditional server, a containerized environment, or serverless platforms.

FastAPI Implementation

FastAPI is built for Python development with automatic API documentation, data validation via Pydantic, and async support out of the box. The framework’s use of Python type hints means you get automatic request validation, serialization, and interactive API docs without writing extra code.

FastAPI’s dependency injection system and Pydantic models create self-documenting, type-safe APIs that catch errors at development time rather than runtime. The framework automatically generates OpenAPI (Swagger) documentation, making your IndexNow endpoint discoverable and testable through a web interface.

Before implementing this endpoint, make sure you’ve generated your IndexNow API key using openssl rand -hex 16 as described earlier in this guide. You’ll also need to create the verification file at public/YOUR_API_KEY.txt containing your key.

Create a Pydantic model and FastAPI endpoint:

FastAPI’s automatic validation means if someone sends invalid data, they get a detailed error response showing exactly what went wrong. The response_model parameter ensures your response always matches the expected schema, and the async/await syntax enables high-performance concurrent request handling. Access your auto-generated API docs at /docs to test the endpoint interactively.

Express.js Implementation

Express is the de facto standard for Node.js web applications, powering countless APIs with its minimal, flexible approach. The framework’s middleware system and routing are battle-tested and understood by millions of developers, making it an excellent choice for adding IndexNow to existing Node.js applications.

Express middleware functions have access to the request and response objects, plus a next function to pass control to the next middleware. This pattern makes it easy to add logging, authentication, or data validation before your route handlers execute. The express.json() middleware automatically parses incoming JSON payloads.

Before implementing this endpoint, make sure you’ve generated your IndexNow API key using openssl rand -hex 16 as described earlier in this guide. You’ll also need to create the verification file at public/YOUR_API_KEY.txt containing your key.

Create an Express route for IndexNow:

Express’s req.get('host') extracts the domain from request headers, and the async/await syntax keeps the code clean despite the asynchronous nature of HTTP requests. This pattern integrates with existing Express applications, and you can add authentication middleware or rate limiting by simply adding more middleware functions before this route handler.

Remix Implementation

Remix brings a fresh approach to React frameworks by embracing web fundamentals and progressive enhancement. Its action and loader pattern provides type-safe data flow between server and client, making it natural to handle IndexNow submissions as part of your form processing workflow.

Remix actions run only on the server, giving you secure access to environment variables and external APIs without exposing sensitive data to the client. The framework’s convention of colocating loaders, actions, and components in a single file keeps related code together, improving maintainability and developer experience.

Before implementing this endpoint, make sure you’ve generated your IndexNow API key using openssl rand -hex 16 as described earlier in this guide. You’ll also need to create the verification file at public/YOUR_API_KEY.txt containing your key.

Create a Remix action for IndexNow:

Remix’s json helper function handles serialization and sets appropriate headers automatically. The framework’s file-based routing means this file at app/routes/api.indexnow.ts automatically creates an endpoint at /api/indexnow. You can call this action from any Remix form using <Form method="post" action="/api/indexnow"> or from client-side code using fetch.

Spring Boot Implementation

Spring Boot brings enterprise-grade Java development to web applications with dependency injection, comprehensive documentation, and a massive ecosystem. The framework’s annotation-based configuration and auto-configuration features mean you can build production-ready REST APIs with minimal boilerplate code.

Spring’s RestController annotation combines Controller and ResponseBody, automatically serializing return values to JSON. The framework’s exception handling, request validation, and extensive integration options make it a solid choice for applications requiring high reliability and scalability.

Before implementing this endpoint, make sure you’ve generated your IndexNow API key using openssl rand -hex 16 as described earlier in this guide. You’ll also need to create the verification file at public/YOUR_API_KEY.txt containing your key.

Create a Spring Boot REST controller:

Configure the RestTemplate bean and add your API key to application properties:

Spring Boot’s @Value annotation injects the API key from application properties, which can reference environment variables. The RestTemplate handles HTTP communication, and ResponseEntity provides fine-grained control over response status codes and headers. This pattern integrates naturally with Spring Security for authentication and Spring’s extensive monitoring and observability features.

ASP.NET Core Implementation

ASP.NET Core brings cross-platform development to the .NET ecosystem with excellent performance and a rich set of built-in features. The framework’s controller-based architecture, dependency injection, and comprehensive middleware pipeline make it ideal for building scalable APIs.

Controllers in ASP.NET Core return IActionResult or Task<IActionResult>, allowing you to return different response types based on the operation’s result. The framework’s model binding automatically deserializes JSON request bodies into C# objects, and returning objects from controller actions automatically serializes them to JSON.

Before implementing this endpoint, make sure you’ve generated your IndexNow API key using openssl rand -hex 16 as described earlier in this guide. You’ll also need to create the verification file at public/YOUR_API_KEY.txt containing your key.

Create an ASP.NET Core controller:

Configure services in your Program.cs or Startup.cs:

ASP.NET Core’s IHttpClientFactory manages HttpClient instances efficiently, preventing socket exhaustion. The framework’s built-in dependency injection makes testing straightforward by allowing easy mocking of dependencies. This controller pattern works with ASP.NET Core’s authentication, authorization, and comprehensive middleware ecosystem.

WordPress Implementation

WordPress powers over 40% of the web, and adding IndexNow to WordPress sites ensures your content reaches search engines quickly. WordPress’s REST API system provides a structured way to create custom endpoints, and the platform’s hook system makes it easy to trigger IndexNow submissions when content changes.

WordPress REST API endpoints follow RESTful conventions with proper authentication and permission checking. The platform’s extensive plugin ecosystem means you can package your IndexNow integration as a reusable plugin, or add it directly to your theme’s functions.php file for site-specific implementations.

Before implementing this endpoint, make sure you’ve generated your IndexNow API key using openssl rand -hex 16 as described earlier in this guide. You’ll also need to create the verification file at public/YOUR_API_KEY.txt containing your key, and store the key in a WordPress constant or option.

Create a WordPress REST API endpoint for IndexNow:

Define your API key in wp-config.php:

WordPress’s wp_remote_post function handles HTTP requests with proper error checking and timeout handling. The permission_callback ensures only authorized users can trigger submissions. The publish_post action hook automatically submits URLs when content is published, providing seamless integration with WordPress’s content workflow.

Testing and Best Practices

To test your setup, first verify the key file is accessible by running curl https://yourdomain.com/19942de05a08448b2f69abd9cfa9f9b8.txt which should return your API key. Then test the API endpoint with curl https://yourdomain.com/api/indexnow to check configuration, and submit a test URL with a POST request containing a JSON body with your URLs array.

When you run your build command, look for output like [indexnow-submit] Found 50 URLs in sitemap followed by [indexnow-submit] ✓ Successfully submitted 50 URLs to IndexNow to confirm everything is working.

Understanding response codes is important. A 200 status means URLs were successfully submitted and will be indexed. A 202 means URLs were received and queued for processing. A 400 indicates a bad request so check your JSON format. A 403 means key verification failed so check your key file is accessible. A 422 means URLs aren’t in your domain or you exceeded the limit. A 429 means you hit the rate limit and need to slow down.

The most important best practice is to only submit when content actually changes. Don’t spam IndexNow with submissions. Submit URLs when you publish new content, when you update existing content significantly, or even when you delete content because search engines need to know about removals too.

Instead of submitting one URL at a time, always batch your submissions:

Always check the response and log failures so you can debug issues. If a submission fails, you might want to retry later or alert your monitoring system.

Remember that IndexNow is a supplement, not a replacement for traditional SEO fundamentals like XML sitemaps, robots.txt, good internal linking structure, and quality content. It works best as part of a comprehensive SEO strategy.

IndexNow doesn’t provide direct feedback on indexing status, so to monitor effectiveness you’ll want to check Bing Webmaster Tools for crawl stats, monitor organic search traffic changes, use site:yourdomain.com searches to verify indexed pages, and track time-to-indexing for new content.

The most common issue you might encounter is a 403 Forbidden error, which means search engines can’t verify your key file. Make sure the file is at your domain root and not in a subdirectory, contains only the key with no extra whitespace, is publicly accessible and not behind authentication, and give it a few minutes after deployment for DNS propagation to complete.

If you get a 422 Unprocessable Entity error, it means your URLs don’t match your host or exceed limits. Ensure all URLs start with your domain, don’t include URLs from other domains, stay under 10,000 URLs per request, and use the correct protocol.

If you’ve submitted URLs but they’re not getting indexed, remember that IndexNow doesn’t guarantee indexing, just notification. Search engines still evaluate content quality before deciding to index. New domains may take longer to build trust, and some content types naturally index faster than others.

IndexNow is completely free with no API keys to purchase and no strict rate limits to worry about. Just keep in mind the 10,000 URLs per request limit, maintain reasonable request frequency without spamming, and ensure all URLs are from the same host.