Search Box SEO Implementation

Search box SEO used to have a clear, tangible payoff. You added a specific piece of structured data, and Google could reward you with an interactive search box embedded in your sitelinks, letting people search your site directly from the results page. That feature is gone. In late 2024 Google announced it was retiring the sitelinks search box, and it no longer appears in search results. So the honest starting point for this topic in 2026 is that the old prize no longer exists.

That does not make the topic pointless. The WebSite SearchAction markup is still valid schema.org, still harmless to keep, and still readable by other tools and agents. And the thing the feature was always a proxy for, a genuinely good on-site search, matters more than ever for user experience and for keeping your index clean. This guide covers the markup for completeness, then the implementation work that actually pays off.

The WebSite SearchAction markup, explained

The markup declares that your site has a search function and describes how to build a search URL. The core mechanism is a URL template containing a placeholder token, search_term_string, that a consumer substitutes with the user's query. Here is a complete, valid example for a site whose search results live at the s query parameter:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "WebSite",
  "url": "https://example.com/",
  "potentialAction": {
    "@type": "SearchAction",
    "target": {
      "@type": "EntryPoint",
      "urlTemplate": "https://example.com/?s={search_term_string}"
    },
    "query-input": "required name=search_term_string"
  }
}
</script>

The three moving parts are the target urlTemplate, which is your search results URL with the token in place of the query, the query-input line, which declares search_term_string as the required input, and the token name itself, which must match between the template and the query-input. If your search results page is example.com/?s=running+shoes, then the template is example.com/?s={search_term_string}. Place the script in the head of your homepage. Note that this markup will not produce a Google search box, because that feature is retired, but it is valid and can be consumed elsewhere, which is why Google advises you do not need to remove existing implementations. For the wider picture of which structured signals machines still read, see our overview of the machine-readable web.

Implementing on-site search that actually helps

With the SERP feature gone, the return on effort shifts entirely to the search experience on your own site. Three things matter.

• Server-rendered results. The results page should render in the initial HTML so it works without JavaScript and is inspectable. A consistent parameter, commonly s or q, keeps URLs predictable.
• Relevance and speed. Slow or irrelevant internal search pushes users back to Google, which is the opposite of what you want. Invest in a search backend that returns fast, ranked, typo-tolerant results.
• Clean result URLs. Every query creates a URL, and left unmanaged those URLs multiply without limit.

That last point is where on-site search most often becomes a technical SEO problem, so it deserves its own section.

Keep search results pages out of the index

Internal search results generate a near-infinite space of low-value URLs: one for every query anyone ever runs, plus pagination and filter combinations. If Google indexes them, you get index bloat, crawl budget waste, and thin pages competing with your real content. The standard fix is a noindex directive on the results template. In an HTML head that looks like this:

<meta name="robots" content="noindex, follow">

The follow value lets Google still traverse any legitimate links on the page while keeping the URL itself out of the index. If crawl budget rather than indexation is your primary concern on a very large site, you can instead disallow the search path in robots.txt, for example Disallow: /?s= or the equivalent for your parameter, though remember that a robots.txt block prevents crawling but does not by itself remove already indexed URLs. For a full treatment of why these generated URLs hurt and how to clean them up, read our guide to index bloat.

Validating the markup you keep

If you retain the WebSite SearchAction block, validate it with the schema.org Schema Markup Validator rather than Google's Rich Results Test. When Google retired the sitelinks search box, it also removed the feature from the Rich Results Test, so that tool will no longer report on this markup and its silence does not mean your markup is broken. The Schema Markup Validator simply confirms the JSON-LD is well formed and that the types and properties are recognised. Check three things specifically: the JSON parses without errors, the urlTemplate contains the search_term_string token exactly as written in query-input, and the target URL actually returns a working results page when you paste it into a browser with a real query substituted. If the template points at a URL that 404s or redirects, the markup is describing a search endpoint that does not exist, which is worse than having no markup at all.

Mine your internal search data

The most underused benefit of on-site search is the data. Every query a visitor types is a direct statement of what they wanted and could not immediately find. Feed your internal search into analytics and review the top queries regularly. High-volume queries with poor results reveal content gaps to fill, and popular terms suggest navigation and hub pages worth building. This is demand research you already own, and it does not depend on any search engine feature existing.

Bottom line

Search box SEO is no longer about earning a widget in Google's results, because that widget is retired. Keep valid WebSite SearchAction markup if you already have it, since it is harmless and still readable by other systems, but do not expect a SERP feature from it. Put your real effort into a fast, server-rendered, relevant on-site search whose result URLs are held out of the index with noindex, and treat the query data as an ongoing source of content ideas. For where this fits among your other structured data, browse our schema and structured data guides.

Frequently asked questions