IndexNow for Job Boards: Implementation Guide

Forty-one percent of job applications arrive within the first 48 hours of a listing going live. Yet standard search engine crawling takes days to weeks to discover new URLs. By the time most organic traffic reaches a listing, its peak application window has already closed. Most job board operators address this by optimizing XML sitemaps and configuring Google's Indexing API. The right instinct, but an incomplete solution. Bing processes a meaningful share of job searches, particularly in enterprise and government environments where Microsoft Edge ships as the default browser, and ignoring that traffic is a blind spot with a simple fix. This guide covers IndexNow implementation for job boards, including how to run it alongside the Google Indexing API so every publish and expiry event reaches all major search engines.

What is IndexNow?

IndexNow is an open-source protocol that lets you notify search engines the moment content changes on your site. Co-created by Microsoft Bing and Yandex and launched in October 2021, it inverts the traditional relationship between publishers and search engines.

Traditional indexing is pull-based: search engines crawl your site on their own schedule, which may be daily, weekly, or whenever their crawl budget allows. You have no way to signal that a URL changed. IndexNow is push-based: when content changes, you notify participating engines via an HTTP request. They prioritize that URL for re-crawling without waiting for their next scheduled pass.

You generate an API key (any alphanumeric string between 8 and 128 characters) and host a plain text verification file at your domain root named after the key (e.g., https://example.com/your-key.txt). From there, you can submit a single URL via HTTP GET or batch up to 10,000 URLs in a single HTTP POST request. The request includes your host, key, and the list of URLs that changed.

IndexNow uses a federated model. You submit to one participating engine (Bing, Yandex, or any other participant), and the protocol routes the notification to all others automatically. You do not need to maintain separate integrations per engine.

Bing reported that IndexNow-submitted URLs accounted for 7% of its clicked URLs in July 2022. By late 2025 that figure had risen to 22%, with the protocol processing over 5 billion URL submissions per day from more than 80 million websites.

IndexNow is a discovery signal, not an indexing guarantee. Submitting a URL tells search engines that something changed and is worth prioritizing. It does not force indexing, override quality assessments, or bypass ranking filters.

Why job boards are the ideal IndexNow use case

No category of website churns URLs faster than a job board. A mid-sized niche board may publish several hundred new listings per week. Enterprise aggregators publish millions. Every new listing is a new URL. Every expired listing is a URL that should stop appearing in search results. That rate of creation and expiry is exactly what IndexNow was designed to handle.

The freshness gap is the core problem. Most applications land within the first few days of a listing going live (56% within 96 hours, according to Federal Reserve data). Standard crawl-based indexing routinely takes longer than that. Without instant indexing, job board SEO traffic arrives after the window has closed. Candidates land on listings that are expiring or already filled. The result is impressions and clicks that convert poorly and frustrate both candidates and employers.

Job boards face five indexing problems that most other site categories do not:

1. Stale listings in search results. Expired jobs that remain indexed send candidates to dead pages, a poor experience that signals low-quality content to search engines.
2. Crawl budget waste. Search engines allocate a finite crawl budget per domain. Spending that budget re-crawling expired listing pages, filtered search result pages, and template variations leaves fewer resources for new, high-value listings.
3. URL churn at scale. Hundreds or thousands of new URLs per week, plus the corresponding expirations, create a constantly shifting index target that scheduled crawling cannot keep pace with.
4. Index bloat from programmatic pages. Programmatic SEO generates location, category, and company pages at scale, many of which thin out over time as listings expire. Without active de-indexing signals, these pages accumulate.
5. Duplicate content from template-based listings. Jobs that share identical or near-identical descriptions (common with multi-location postings) create patterns that crawlers handle poorly without clear canonical and freshness signals.

IndexNow directly addresses the first three. Submitting a URL the moment a listing is published tells search engines to prioritize it immediately rather than wait for the next crawl cycle. Submitting that same URL when the listing expires, or when its validThrough property passes, signals that the page is no longer current, allowing faster de-indexing and reducing crawl budget waste. Coordinating IndexNow with proper JobPosting structured data and validThrough dates creates a complete freshness signal stack: structured data tells Google what the listing contains and when it expires, IndexNow tells all participating engines when to act on that information.

The boards that have invested in indexing infrastructure see measurable results. Jobrapido reported a 182% organic traffic increase following its Google for Jobs integration, partly from faster indexing of new listings during their peak application window. LinkedIn Jobs has built programmatic SEO infrastructure across over a million pages with deliberate freshness management. Indeed operates at a scale where indexing lag is a direct revenue problem, not a theoretical concern.

An XML sitemap tells search engines which URLs exist, but engines decide when (and whether) to crawl them. For stable content like blog posts, that lag is acceptable. For a listing that expires in seven days, a crawl delay of three to five days erases most of the indexable window. IndexNow eliminates that dependency on the engine's crawl schedule.

Which search engines IndexNow reaches, and the one it doesn't

As of February 2026, seven entities participate in the IndexNow protocol: Bing (co-creator), Yandex (co-creator), Naver (joined July 2023, dominant in South Korea), Seznam (Czech Republic's leading search engine), Yep (Ahrefs' search engine), Amazon (joined mid-June 2025 for Amazonbot), and the generic api.indexnow.org endpoint that routes submissions to all participants simultaneously.

Google does not support IndexNow.

In late 2021, Google said it would "test the potential benefits" of the protocol. More than four years later, nothing has shipped.

The reasons are structural, not technical. Google operates the largest crawl infrastructure on the planet, representing billions in capital expenditure built over two decades. IndexNow solves a discovery problem Google largely doesn't have. Beyond that, the protocol requires submitting URLs to a shared endpoint, which effectively shares signals with Bing and Yandex. Google has no incentive to hand competitors a real-time feed of content changes. It also has its own fast-track mechanism, the Indexing API, and its crawl infrastructure collects data well beyond content discovery.

DuckDuckGo benefits indirectly since it sources organic results primarily from Bing's index. Any URL that IndexNow pushes into Bing surfaces in DuckDuckGo without a separate submission.

Amazon's participation matters for job boards. Amazonbot's inclusion means submitted URLs can feed Amazon's AI-powered features and search surfaces. For boards publishing roles at Amazon-affiliated companies or targeting visibility in Amazon's growing AI discovery layer, this is low-effort upside.

Many job board operators underestimate how much Bing traffic matters. Enterprise and government sectors default to Microsoft Edge, where Bing is the built-in search engine. Microsoft Copilot draws from Bing's index for AI-generated answers, and ChatGPT Search also pulls from Bing when answering queries with web results. These AI surfaces are growing fast, and URLs indexed quickly on Bing surface in AI-generated answers sooner. If Bing represents even 5–10% of your search traffic, that translates to real job applications. Factor in AI search traffic on top, and the case for instant Bing indexing gets stronger every quarter.

IndexNow vs. Google Indexing API for job boards

These two protocols are complementary, not competing. Where you use each is the key decision in your indexing setup.

Google's Indexing API was purpose-built for job postings. It launched in June 2018 specifically to accelerate JobPosting schema markup into Google for Jobs. That origin matters: it remains the only official fast-track route into Google's index, and for most job boards, Google accounts for the vast majority of job search traffic. If you publish structured job data and want it in Google for Jobs quickly, the Indexing API is non-negotiable.

IndexNow covers the ground Google's API doesn't touch: Bing, Yandex, Naver, and the rest. Together, they eliminate the crawl-budget lottery across every major search surface.

The default Google Indexing API quota is 200 URLs per day, which works without any approval. A September 2024 change added a requirement for boards that need higher quotas: you must submit a request form and wait for Google to approve the increase. For small to mid-sized boards, 200/day is enough to cover daily publishes and expirations. Larger boards that exceed that limit face an approval process with no guaranteed timeline. Setting up a Google Cloud project, configuring OAuth 2.0, creating a service account, and verifying ownership in Google Search Console is required regardless of quota level.

IndexNow requires none of this. You host a text file, make an HTTP POST, and submissions process immediately. For a job board launching today, IndexNow is the only instant indexing option available on day one.

The dual approach matters most for expired listings. When a job closes, you need to clean up stale URLs across all search engines, not just Google. Send a URL_DELETED action to the Google Indexing API and submit the same URL (now returning a 410 response) through IndexNow. Engines on both sides of the protocol deindex accordingly. Leaving expired job URLs in search results degrades user experience and, over time, signals quality problems to search engines.

XML sitemaps remain the baseline safety net. They are not fast (Googlebot and Bingbot crawl them on their own schedules), but they ensure every URL eventually gets discovered regardless of whether an API submission succeeded.

For the complete Google Indexing API setup, see our Google Indexing API integration guide.

The dual-protocol architecture

Think of content lifecycle events as triggers rather than scheduled tasks. The examples below use job listings, but IndexNow accepts any URL, so the same pattern applies to company pages and blog posts. The key difference is that the Google Indexing API only accepts JobPosting URLs.

Job published. A trigger fires immediately after the record is written to the database. Two parallel requests go out: a URL_UPDATED action to the Google Indexing API and a URL submission to the IndexNow endpoint. The XML sitemap updates in the background.

Job updated. Any change to a job's title, description, salary, or status fires the same dual submission. Both protocols accept repeated submissions for the same URL without penalty.

Job expired. The most important event. The job record is marked inactive, the URL returns a 410 Gone response, and two requests fire: URL_DELETED to Google's Indexing API and submission of the 410 URL to IndexNow. Both protocols are designed to handle this. IndexNow explicitly supports URLs returning 404 or 410 as a deindexing signal.

XML sitemap. Updated on every publish, update, and expiry as a passive fallback. If an API request fails, the sitemap ensures eventual discovery.

How to set up IndexNow on your job board

Generate and host your API key

Your API key is a string of 8–128 alphanumeric characters. Lowercase hex is the recommended format, something like a3f8b2e1d4c7f0a9b5e2d8c1f4a7b3e0. You can generate one yourself using any random hex generator, or let Bing Webmaster Tools create one for you automatically.

Create a plain text file named {your-key}.txt containing only the key string. No whitespace, no extra lines. Host it at your domain root:

1
https://yourdomain.com/a3f8b2e1d4c7f0a9b5e2d8c1f4a7b3e0.txt

Search engines verify this file before processing submissions. If it returns a non-200 status, your submissions will be rejected with a 403. Test it in a browser before submitting any URLs.

Submit a single URL

A single-URL submission is a plain HTTP GET request. The api.indexnow.org address federates to all participating engines, so you only need one call:

1
https://api.indexnow.org/indexnow?url=https://yourdomain.com/jobs/senior-engineer-123&key=YOUR_KEY

If your key file is not at the domain root, add a keyLocation parameter pointing to its actual URL. Here is a TypeScript implementation:

1234567891011
async function submitToIndexNow(
  url: string,
  apiKey: string,
): Promise<number> {
  const endpoint = new URL('https://api.indexnow.org/indexnow');
  endpoint.searchParams.set('url', url);
  endpoint.searchParams.set('key', apiKey);

  const response = await fetch(endpoint.toString());
  return response.status;
}

The pattern is identical in Python (requests.get) and PHP (file_get_contents or cURL).

Submit URLs in bulk

If you post more than a handful of jobs per day, use the batch POST endpoint. It accepts up to 10,000 URLs per request:

1234567891011121314151617181920
async function submitBatchToIndexNow(
  urls: string[],
  apiKey: string,
  host: string,
): Promise<number> {
  const payload = {
    host,
    key: apiKey,
    keyLocation: `https://${host}/${apiKey}.txt`,
    urlList: urls,
  };

  const response = await fetch('https://api.indexnow.org/indexnow', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json; charset=utf-8' },
    body: JSON.stringify(payload),
  });

  return response.status;
}

One constraint: all URLs in a single batch must share the same host. If your board serves listings across multiple subdomains (say jobs.example.com and careers.example.com), submit separate batches for each.

Response codes and what they mean

A 202 is not an error. It means the engine received your submission and will validate your key file before crawling. Once verified, subsequent submissions from the same key typically return 200.

Managing the job listing lifecycle with IndexNow

Why expired job management matters

Stale listings are the most common and most damaging SEO problem on job boards. Google has issued manual actions against sites that serve JobPosting structured data on pages for roles that have already been filled. The structured data signals that the job is open when it is not, which can trigger a penalty affecting your entire site's visibility.

Beyond penalties, candidates who land on expired listings bounce immediately. That signal compounds over time, telling search engines that your pages do not satisfy intent.

IndexNow's documentation confirms it accepts URLs returning 404 or 410 status codes. This is how you actively signal removal rather than waiting for search engines to rediscover the status on their next crawl.

The four lifecycle events

Every job listing passes through predictable states. Here is what to submit at each one:

1. Job published. Submit the URL through IndexNow immediately after the listing goes live. The page should return 200 with complete JobPosting structured data including validThrough. Pair with a Google Indexing API URL_UPDATED call for maximum coverage.

2. Job updated. Resubmit the URL any time substantive content changes: title, salary, location, or description. Search engines will recrawl and index the updated version.

3. Job expired. Two approaches:

• Soft expire: Keep the page live. Remove all JobPosting structured data, display a clear "This role is no longer accepting applications" message, and surface similar open listings. Submit through IndexNow so engines recrawl and see the schema is gone.
• Hard expire: Return HTTP 410 (Gone), not 404. A 410 explicitly signals permanent removal. Submit the 410 URL through IndexNow to accelerate deindexing.

4. Job deleted. Return 410 and submit through IndexNow. Do not redirect deleted listings to your homepage. Engines will follow the redirect and index the destination instead.

A lifecycle handler that coordinates both protocols:

1234567891011121314151617
type JobEvent = 'published' | 'updated' | 'expired' | 'deleted';

async function handleJobIndexing(
  jobUrl: string,
  event: JobEvent,
  apiKey: string,
  host: string,
): Promise<void> {
  // Notify IndexNow for every lifecycle event, including expired and deleted.
  // IndexNow triggers a recrawl; the engine sees the 410 or updated schema.
  await submitBatchToIndexNow([jobUrl], apiKey, host);

  // For Google: use the Indexing API with the appropriate action.
  // URL_UPDATED for 'published' and 'updated'
  // URL_DELETED for 'expired' (hard) and 'deleted'
  // Full implementation: /blog/google-indexing-api-job-postings
}

Batch expiry processing

Job boards rarely expire one listing at a time. A nightly cleanup job might retire hundreds of listings simultaneously. Collect all expired URLs and submit them as a single batch:

1234567891011
async function expireJobListings(
  expiredUrls: string[],
  apiKey: string,
  host: string,
): Promise<void> {
  // IndexNow handles up to 10,000 URLs per request
  for (let i = 0; i < expiredUrls.length; i += 10_000) {
    const batch = expiredUrls.slice(i, i + 10_000);
    await submitBatchToIndexNow(batch, apiKey, host);
  }
}

A single batch submission notifies Bing, Yandex, and every other participating engine simultaneously. Stale listings are cleaned up across the board rather than one engine at a time.

Batching strategy and rate limits for high-volume boards

IndexNow's 10,000-URL batch limit is far more generous than Google's Indexing API, which caps batches at 100 requests. For most job boards, a single nightly batch handles everything. For boards posting 500 or more jobs per day, the approach needs more structure.

There is no confirmed daily submission cap, but IP-based rate limiting applies. A 429 response means you have hit it. The safest approach is to queue submissions and flush them in batches every 5–15 minutes rather than submitting each URL individually as it is created.

Prioritize your queue by time-sensitivity:

1. New listings: most urgent, directly affect revenue and candidate experience
2. Updated listings: important but less time-critical
3. Expired and deleted listings: should be processed daily at minimum, ideally within hours

A queue processor with prioritization and rate-limit recovery:

123456789101112131415161718192021
async function processIndexNowQueue(
  queue: Array<{ url: string; priority: number }>,
  apiKey: string,
  host: string,
): Promise<void> {
  // Sort ascending: 1 = new listings, 2 = updated, 3 = expired/deleted
  const sorted = [...queue].sort((a, b) => a.priority - b.priority);

  for (let i = 0; i < sorted.length; i += 10_000) {
    const batch = sorted.slice(i, i + 10_000);
    const urls = batch.map((item) => item.url);

    const status = await submitBatchToIndexNow(urls, apiKey, host);

    if (status === 429) {
      // Rate limited. Wait 60 seconds then retry.
      await new Promise((resolve) => setTimeout(resolve, 60_000));
      i -= 10_000;
    }
  }
}

For production use, replace the fixed 60-second delay with exponential backoff. Start at 60 seconds, double on each consecutive 429, and cap at 10–15 minutes. Log every 429 so you can monitor whether your volume consistently hits the limit.

For very high-volume boards (10,000+ URL changes per day), consider submitting directly to specific engine endpoints (https://www.bing.com/indexnow, https://yandex.com/indexnow) in addition to the federated endpoint. Direct submission gives you more control and avoids any federation latency.

How Cavuno handles IndexNow and the Google Indexing API automatically

Setting up IndexNow manually takes five minutes if you're comfortable with HTTP requests and hosting static files. The harder part is maintaining the full infrastructure over time: Google Indexing API provisioning, credential management, submission queues that fire on the right lifecycle events, quota tracking, and expired job cleanup. Most job board operators don't want to own that operational burden.

Cavuno automates both protocols end to end.

IndexNow enabled by default. Every Cavuno board submits to Bing, Yandex, and all participating IndexNow engines automatically from day one. No API keys to generate, no verification files to host, no code to write. When a job is published, updated, or expires, Cavuno submits the URL. Company pages and blog posts are also submitted. Programmatic SEO pages (location and category pages) are not yet submitted automatically. Toggle IndexNow on or off from Board Settings → General.

Google Indexing API automatic provisioning. When you enable the Google Indexing API, Cavuno creates a dedicated Google Cloud project, enables the Web Search Indexing API, and generates a service account, all behind the scenes in about two minutes. The only steps you perform manually are adding the service account email as an Owner in Google Search Console and enabling the toggle.

Encrypted credential storage. Service account keys are encrypted at rest. You never download or manage raw API credentials.

Automatic submission queue. Database triggers fire when jobs are published, updated, or deleted. Cavuno batches URLs and submits to both protocols, respecting Google's rate limits and daily quota. New publishes are prioritized over updates, and updates over deletions.

Quota tracking. A settings dashboard shows your daily Google Indexing API usage against your limit (default 200/day). Request a quota increase from Google directly from the settings page.

Lifecycle management. When a job expires, Cavuno sends URL_DELETED to Google and resubmits through IndexNow so engines recrawl and see the updated state. No stale listings.

As far as we know, no other job board platform offers built-in IndexNow. And no other platform auto-provisions the Google Indexing API. Every competitor requires you to manually create a Google Cloud project, generate credentials, and upload key files. If you're evaluating job board software, indexing infrastructure is one of the details that separates platforms built for SEO from those that treat it as an afterthought.

If you're not using Cavuno

The manual setup described earlier in this guide works for any platform or custom build.

For WordPress with WP Job Manager, the official Microsoft IndexNow plugin handles submissions automatically. Rank Math and Yoast Premium both include IndexNow support. If you are running either plugin, you may already have it available.

For custom builds, the TypeScript code examples above are production-ready starting points. Adapt the key hosting and batch submission to your stack.

For Cloudflare users, enable Crawler Hints in the dashboard, a single toggle that submits changed URLs to IndexNow automatically without code changes.

For the Google Indexing API side of the dual-protocol setup, see the Google Indexing API integration guide.

Measuring IndexNow impact

The primary measurement tool is Bing Webmaster Tools. The IndexNow Insights Report, added in March 2024, shows submitted URLs, how many were crawled, and how many were indexed. This is the closest thing to a feedback loop for IndexNow submissions.

To measure indexing speed improvement, check "Discovered - currently not indexed" and "Crawled - currently not indexed" in Bing Webmaster Tools before and after enabling IndexNow. A shrinking backlog, particularly for recently submitted URLs, signals that submissions are working. Segment your analytics to track Bing organic traffic specifically to job listing pages. Increased indexed volume should be reflected in referral traffic over time.

If Google drives the vast majority of your organic job traffic, IndexNow alone will not transform your numbers. Its value is coverage completeness. Bing, Yandex, and the growing set of AI-powered surfaces that pull from Bing's index all work from current data, at zero setup cost. Combined with the Google Indexing API, you have instant submission across all major search engines.

No job board-specific benchmarks exist yet. Available data shows Bing indexing pages in under one hour with IndexNow versus up to 24 hours without (Wix case study). One tech publisher reported moving from 48 hours to 30 minutes. Job boards should expect similar directional improvement, though exact numbers depend on domain authority and existing crawl frequency.

Start with IndexNow, then complete the picture

Job boards need both protocols. The Google Indexing API covers Google, where the vast majority of job searches happen. IndexNow covers everything else: Bing, Yandex, and the expanding set of AI search surfaces that pull from Bing's index. Neither replaces the other. Running them in parallel gives you complete coverage across every major search engine.

The setup cost is minimal and the ongoing cost is zero. There is no reason to leave Bing, Yandex, and emerging search engines discovering your listings on their own schedule when you can signal every change immediately.

Start with IndexNow today. Generate a key, host the verification file, and submit your first batch. Then set up the Google Indexing API for complete coverage.