Code snippets

# 1. Reverse DNS: Googlebot and Google's other common crawlers resolve to crawl-*.googlebot.com
#    or geo-crawl-*.geo.googlebot.com; special-case crawlers to rate-limited-proxy-*.google.com.
#    A host such as 81.59.117.34.bc.googleusercontent.com is a Google Cloud customer, not Googlebot.
host 66.249.66.1
# -> 1.66.249.66.in-addr.arpa domain name pointer crawl-66-249-66-1.googlebot.com.

# 2. Forward DNS: that host name must resolve back to the same IP
host crawl-66-249-66-1.googlebot.com
# -> crawl-66-249-66-1.googlebot.com has address 66.249.66.1

# Common crawlers (Googlebot and others) and special-case crawlers; refresh the lists regularly
curl -s https://developers.google.com/static/crawling/ipranges/common-crawlers.json
curl -s https://developers.google.com/static/crawling/ipranges/special-crawlers.json

HTTP/1.1 503 Service Unavailable
Content-Type: text/html; charset=utf-8
Retry-After: 3600
Cache-Control: no-store

server {
    listen 443 ssl;
    server_name www.example.com;
    ssl_certificate     /etc/ssl/www.example.com.crt;
    ssl_certificate_key /etc/ssl/www.example.com.key;

    error_page 503 /maintenance.html;

    location = /maintenance.html {
        root /var/www/static;
        internal;
        # add_header here replaces server-level add_header lines: repeat HSTS or CSP if you set them
        add_header Retry-After 3600 always;
        add_header Cache-Control "no-store" always;
    }

    # robots.txt keeps answering 200 during maintenance
    location = /robots.txt {
        root /var/www/static;
    }

    location / {
        return 503;
    }
}

# https://www.example.com/robots.txt
User-agent: *
# Internal search results and cart/checkout actions (adapt to your URL patterns)
Disallow: /search?
Disallow: /cart/
Disallow: /checkout/
# (Shops in Google Shopping: give Storebot-Google its own group that leaves cart and checkout open.
#  A named group replaces this * group for that crawler, so repeat in it every rule that should still apply.)
# Filter and sort parameters of faceted navigation, as the first parameter (?) or a later one (&);
# /*?*size= would also block ?pagesize= and /*?*color= would block ?bgcolor=
Disallow: /*?color=
Disallow: /*&color=
Disallow: /*?size=
Disallow: /*&size=
Disallow: /*?sort=
Disallow: /*&sort=
# API: blocked in general, but the endpoints pages render from stay crawlable
# (the longer, more specific Allow rule wins)
Disallow: /api/
Allow: /api/products/
Allow: /api/reviews/
# Never disallow /static/, /assets/ or other JS and CSS folders

# Optional: keep content out of Gemini training and grounding (no effect on Google Search)
User-agent: Google-Extended
Disallow: /

Sitemap: https://www.example.com/sitemap.xml

GET /chairs/oak-dining-chair HTTP/1.1
Host: www.example.com
If-None-Match: "a3f9c2e1"

HTTP/1.1 304 Not Modified
ETag: "a3f9c2e1"
Cache-Control: no-cache

// Express: strong ETags, and an automatic 304 when If-None-Match matches
const express = require('express');
const app = express();
app.set('etag', 'strong');

app.get('/chairs/:slug', async (req, res) => {
  const html = await renderChairPage(req.params.slug); // your server-side renderer
  res.set('Cache-Control', 'no-cache'); // may be stored, but must be revalidated
  res.type('html').send(html); // res.send() compares the ETag and answers 304 when fresh
});

// Pages with a per-request nonce or CSRF token: an ETag from the data, not from the body
const crypto = require('crypto');
const TEMPLATE_VERSION = '2026-10-02';
app.get('/products/:slug', async (req, res) => {
  const product = await loadProduct(req.params.slug); // your data access
  const etag = '"' + crypto.createHash('sha256').update(JSON.stringify(product) + TEMPLATE_VERSION).digest('hex').slice(0, 16) + '"';
  res.set('ETag', etag);
  res.set('Cache-Control', 'no-cache');
  if (req.fresh) return res.status(304).end(); // If-None-Match matches the data ETag
  res.type('html').send(renderProductPage(product, res.locals.cspNonce));
});

# WRONG: the googlebot group replaces the * group instead of adding to it,
# so Googlebot may crawl /goats/ and /cows/ and only /dogs/ is closed to it
User-agent: *
Disallow: /goats/
Disallow: /cows/

User-agent: googlebot
Disallow: /dogs/

# Shared rules for every crawler without a group of its own
User-agent: *
Disallow: /goats/
Disallow: /cows/
Disallow: /staging/

# Googlebot: the shared rules again, plus its own
User-agent: googlebot
Disallow: /goats/
Disallow: /cows/
Disallow: /dogs/
Disallow: /staging/
Allow: /staging/preview/

# Several crawlers can share one group: stack their user-agent lines with nothing in between
User-agent: bingbot
User-agent: applebot
Disallow: /goats/
Disallow: /cows/
Disallow: /staging/

Sitemap: https://www.example.com/sitemap.xml

<!-- Crawlable: <a> with a real relative or absolute URL -->
<a href="/chairs/">Chairs</a>
<a href="https://www.example.com/chairs/oak-dining-chair">Oak dining chair</a>

<!-- Crawlable and still client-side routed: keep the href, intercept the click in JavaScript -->
<a href="/chairs/" data-link>Chairs</a>

<!-- Not dependable: do not use for anything that should be discovered -->
<a onclick="goTo('/chairs/')">Chairs</a>
<a routerLink="/chairs/">Chairs</a>
<a href="javascript:goTo('chairs')">Chairs</a>
<a href="#/chairs">Chairs</a>
<span data-href="/chairs/" onclick="location.href=this.dataset.href">Chairs</span>
<button type="button" onclick="location.href='/chairs/'">Chairs</button>

<nav>
  <a href="/" data-link>Home</a>
  <a href="/chairs/" data-link>Chairs</a>
  <a href="/tables/" data-link>Tables</a>
</nav>
<main id="app"></main>

<script>
  const routes = {
    '/': () => '<h1>Example Shop</h1>',
    '/chairs/': () => '<h1>Chairs</h1>',
    '/tables/': () => '<h1>Tables</h1>',
    '/not-found': () => '<h1>Page not found</h1>', // the server answers this URL with 404
  };

  function renderRoute(path) {
    const view = routes[path];
    if (!view) {
      // Unknown route on a 200 URL: go to the URL the server answers with 404 (once; never loop)
      if (path !== '/not-found') window.location.replace('/not-found');
      return;
    }
    document.getElementById('app').innerHTML = view();
  }

  document.addEventListener('click', (event) => {
    const link = event.target.closest('a[data-link]');
    if (!link || link.origin !== location.origin) return;
    if (event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
    event.preventDefault();
    history.pushState({}, '', link.pathname + link.search);
    renderRoute(link.pathname);
  });

  window.addEventListener('popstate', () => renderRoute(location.pathname));
  renderRoute(location.pathname);
</script>

<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <sitemap>
    <loc>https://www.example.com/sitemaps/products-1.xml</loc>
    <lastmod>2026-09-30T06:00:00+00:00</lastmod>
  </sitemap>
</sitemapindex>

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://www.example.com/chairs/oak-dining-chair</loc>
    <lastmod>2026-09-28T10:15:00+00:00</lastmod>
  </url>
  <url>
    <loc>https://www.example.com/chairs/beech-stool</loc>
    <lastmod>2026-09-12T08:00:00+00:00</lastmod>
  </url>
</urlset>

<!-- https://www.example.com/chairs/?page=2 -->
<head>
  <title>Chairs, page 2 | Example Shop</title> <!-- the page number is optional -->
  <link rel="canonical" href="https://www.example.com/chairs/?page=2">
</head>
<body>
  <main>
    <h1>Chairs</h1>
    <ul>
      <li><a href="/chairs/oak-dining-chair">Oak dining chair</a></li>
      <li><a href="/chairs/beech-stool">Beech stool</a></li>
    </ul>
    <nav aria-label="Pagination">
      <a href="/chairs/">1</a>
      <a href="/chairs/?page=2" aria-current="page">2</a>
      <a href="/chairs/?page=3">3</a>
      <a href="/chairs/?page=3">Next page</a>
    </nav>
  </main>
</body>

<!-- Images and iframes: native lazy loading, real src in the HTML -->
<img src="/img/oak-chair-800.webp" alt="Oak dining chair with a woven paper-cord seat" width="800" height="600" loading="lazy">

<!-- Lists: page 1 of /chairs/, a sentinel for the observer, and pagination links the script never removes -->
<ul id="products">
  <li><a href="/chairs/oak-dining-chair">Oak dining chair</a></li>
</ul>
<div id="load-more-sentinel" style="height: 1px"></div>
<nav aria-label="Pagination">
  <a href="/chairs/" aria-current="page">1</a>
  <a href="/chairs/?page=2">2</a>
  <a href="/chairs/?page=3">3</a>
  <a href="/chairs/?page=2">Next page</a>
</nav>

<!-- Avoid: window.addEventListener('scroll', loadMoreProducts) never runs for Googlebot -->

<script>
  const list = document.getElementById('products');
  const sentinel = document.getElementById('load-more-sentinel');
  let next = '/chairs/?page=2'; // written by the server: the next page's URL, empty on the last page

  const observer = new IntersectionObserver(async ([entry]) => {
    if (!entry.isIntersecting || !next) return;
    observer.unobserve(sentinel);
    const url = new URL(next, location.href);
    const res = await fetch('/fragments' + url.pathname + url.search); // returns the <li> items of that page
    if (!res.ok) { observer.disconnect(); return; } // keep the links; never insert an error page
    list.insertAdjacentHTML('beforeend', await res.text());
    history.replaceState({}, '', url.pathname + url.search); // the URL follows the chunk once it is in place
    next = res.headers.get('X-Next-Page') || ''; // e.g. "/chairs/?page=3", absent on the last page
    if (next) observer.observe(sentinel); else observer.disconnect();
  });

  if (next) observer.observe(sentinel);
</script>

const ORIGIN = 'https://www.example.com';
// Parameters each route actually uses, in the order they must appear.
const PARAMS = { '/chairs': ['colour', 'page'], '/search': ['q'] };

function expectedUrl(pathname, searchParams) {
  let path = pathname.toLowerCase().replace(/\/{2,}/g, '/');
  if (path.length > 1 && path.endsWith('/')) path = path.slice(0, -1);
  const kept = new URLSearchParams();
  for (const name of PARAMS[path] || []) {
    const value = searchParams.get(name);
    if (value) kept.set(name, value); // unused and empty parameters are dropped
  }
  const query = kept.toString();      // spaces always come out as +
  return path + (query ? '?' + query : '');
}

app.set('trust proxy', true);         // so req.protocol is right behind a CDN or load balancer
app.use((req, res, next) => {
  const requested = new URL(ORIGIN + req.originalUrl); // not new URL(path, base): '//x' would parse as a host
  const expected = expectedUrl(requested.pathname, requested.searchParams);
  const wrongOrigin = req.protocol !== 'https' || req.hostname !== 'www.example.com';
  if (wrongOrigin || expected !== requested.pathname + requested.search) {
    return res.redirect(301, ORIGIN + expected); // one hop, straight to the final URL
  }
  next();
});

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Oak dining chair with woven seat | Example Shop</title>
  <meta name="description" content="Solid oak dining chair with a hand-woven paper-cord seat. Seat height 45 cm, delivered assembled.">
  <link rel="canonical" href="https://www.example.com/chairs/oak-dining-chair">
  <meta name="robots" content="max-snippet:-1, max-image-preview:large">
</head>
<body>
  <header>
    <a href="/">Example Shop</a>
    <nav aria-label="Main">
      <a href="/chairs/">Chairs</a>
      <a href="/tables/">Tables</a>
    </nav>
  </header>

  <main>
    <article>
      <h1>Oak dining chair with woven seat</h1>
      <p>A solid oak dining chair with a hand-woven paper-cord seat, made for everyday family meals.</p>
      <figure>
        <img src="/img/oak-chair-1200.webp" alt="Oak dining chair with a woven paper-cord seat, seen from the front" width="1200" height="900">
        <figcaption>Natural oak finish, seat height 45 cm.</figcaption>
      </figure>
      <h2>Dimensions and materials</h2>
      <p>Width 46 cm, depth 52 cm, height 80 cm. <strong>Solid European oak</strong>, paper-cord seat.</p>
    </article>
  </main>

  <footer>
    <nav aria-label="Footer">
      <a href="/delivery/">Delivery</a>
      <a href="/returns/">Returns</a>
      <a href="/contact/">Contact</a>
    </nav>
  </footer>
</body>
</html>

<div class="tabs">
  <div role="tablist" aria-label="Product details">
    <button type="button" role="tab" id="tab-specs" aria-controls="panel-specs" aria-selected="true">Specifications</button>
    <button type="button" role="tab" id="tab-care" aria-controls="panel-care" aria-selected="false">Care</button>
  </div>
  <section role="tabpanel" id="panel-specs" aria-labelledby="tab-specs">
    <p>Seat height 45 cm, solid oak frame, paper-cord seat.</p>
  </section>
  <section role="tabpanel" id="panel-care" aria-labelledby="tab-care" hidden>
    <p>Wipe with a damp cloth; re-oil the frame once a year.</p>
  </section>
</div>

<!-- Avoid: tab.onclick = () => fetch('/api/specs') ... content that exists only after a click -->

<script>
  const tabs = document.querySelectorAll('[role="tab"]');
  tabs.forEach((tab) => {
    tab.addEventListener('click', () => {
      tabs.forEach((other) => {
        const selected = other === tab;
        other.setAttribute('aria-selected', String(selected));
        document.getElementById(other.getAttribute('aria-controls')).hidden = !selected;
      });
    });
  });
</script>

<main>
  <h1>Our stores</h1>
  <ul id="stores">
    <li>Barcelona, Carrer Example 1</li>
    <li>Madrid, Calle Example 2</li>
  </ul>
  <button type="button" id="near-me" hidden>Sort by distance</button>
  <canvas class="hero-effect" width="1200" height="400"></canvas>
</main>

<script>
  // Location: optional, only after a user click; the full list is already in the page
  if ('geolocation' in navigator) {
    const button = document.getElementById('near-me');
    button.hidden = false;
    button.addEventListener('click', () => {
      navigator.geolocation.getCurrentPosition(
        (position) => sortStoresByDistance(position.coords),
        () => {} // declined or unavailable: keep the default order
      );
    });
  }

  function sortStoresByDistance(coords) {
    console.log('Sort stores near', coords.latitude, coords.longitude);
  }

  // WebGL: decoration only; without it the server-rendered text and images stay as they are
  const canvas = document.querySelector('canvas.hero-effect');
  const gl = canvas.getContext('webgl');
  if (gl) {
    gl.clearColor(0.1, 0.3, 0.5, 1.0);
    gl.clear(gl.COLOR_BUFFER_BIT);
  } else {
    canvas.remove();
  }
</script>

<!-- Indexable templates: allow full-length snippets and large image and video previews -->
<meta name="robots" content="max-snippet:-1, max-image-preview:large, max-video-preview:-1">

<!-- Keep a page out of Search (internal admin, thin or temporary pages) -->
<meta name="robots" content="noindex">

<!-- The same rule for Google only -->
<meta name="googlebot" content="noindex">

<!-- Time-limited page (event, offer, job ad): drop it from results after the end date -->
<meta name="robots" content="unavailable_after: 2026-12-31T23:59:59+01:00">

HTTP/1.1 200 OK
Content-Type: application/pdf
X-Robots-Tag: noindex

# Inside the server block: office documents out of the index.
# An add_header in a location replaces every add_header set at server level for those responses:
# repeat your HSTS and CSP lines in each such location (or use the headers-more module).
location ~* \.(pdf|docx?|xlsx?)$ {
    add_header X-Robots-Tag "noindex" always;
    add_header Strict-Transport-Security "max-age=31536000" always;  # repeated from the server block
}

# Images that must not appear in Google Images (they still display on your pages)
location ^~ /internal-images/ {
    add_header X-Robots-Tag "noindex" always;
    add_header Strict-Transport-Security "max-age=31536000" always;  # repeated from the server block
}

<FilesMatch "\.(pdf|docx?|xlsx?)$">
  Header set X-Robots-Tag "noindex"
</FilesMatch>

<p>
  Call our workshop on <span data-nosnippet>+1 555-0100</span> for a repair quote.
</p>

<section data-nosnippet>
  <h2>Member prices</h2>
  <p>Log in to see your personal discount.</p>
</section>

# http:// on both host names -> https://www. in one hop
server {
    listen 80;
    server_name example.com www.example.com;
    return 301 https://www.example.com$request_uri;
}

# https:// on the bare domain -> https://www.
server {
    listen 443 ssl;
    server_name example.com;
    ssl_certificate     /etc/ssl/example.com.crt;
    ssl_certificate_key /etc/ssl/example.com.key;
    return 301 https://www.example.com$request_uri;
}

server {
    listen 443 ssl;
    http2 on;  # nginx 1.25.1+; older versions use "listen 443 ssl http2;"
    server_name www.example.com;
    ssl_certificate     /etc/ssl/www.example.com.crt;
    ssl_certificate_key /etc/ssl/www.example.com.key;

    # Moved pages: permanent and straight to the final URL
    location = /old-chairs/ {
        return 301 https://www.example.com/chairs/;
    }
    location ^~ /shop/chairs/ {
        rewrite ^/shop/chairs/(.*)$ https://www.example.com/chairs/$1 permanent;
    }

    root /var/www/example;
}

<!-- On https://www.example.com/chairs/oak-dining-chair
     and on https://www.example.com/chairs/oak-dining-chair?utm_source=newsletter -->
<head>
  <link rel="canonical" href="https://www.example.com/chairs/oak-dining-chair">
</head>

HTTP/1.1 200 OK
Content-Type: application/pdf
Link: <https://www.example.com/guides/chair-care.pdf>; rel="canonical"

# check_chain.py  -  usage: python check_chain.py https://www.example.com/page [more URLs]
import sys
from urllib.parse import urljoin, urlsplit

import requests
from protego import Protego

AGENTS = {
    "googlebot": "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)",
    "browser": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0 Safari/537.36",
}
TOKEN = "Googlebot"  # the robots.txt token the rules are tested for
_robots = {}


def robots_for(url):
    parts = urlsplit(url)
    origin = f"{parts.scheme}://{parts.netloc}"
    if origin not in _robots:
        r = requests.get(origin + "/robots.txt", headers={"User-Agent": AGENTS["googlebot"]}, timeout=10)
        if r.status_code == 200:
            text = r.text
        elif 400 <= r.status_code < 500 and r.status_code != 429:
            text = ""  # 4xx (except 429): Google crawls as if there were no robots.txt
        else:
            text = "User-agent: *\nDisallow: /"  # 5xx or 429: Google stops crawling the host for now
        _robots[origin] = Protego.parse(text)
    return _robots[origin]


def check(url, agent, max_hops=10):
    print(f"[{agent}]")
    for hop in range(max_hops + 1):
        allowed = robots_for(url).can_fetch(url, TOKEN)
        print(f"  {hop}: {'allowed' if allowed else 'BLOCKED by robots.txt'}  {url}")
        if not allowed:
            print("     crawling stops here; Search Console reports the first URL of the chain as blocked")
            return
        r = requests.get(url, headers={"User-Agent": AGENTS[agent]}, allow_redirects=False, timeout=10)
        location = r.headers.get("Location")
        if r.status_code in (301, 302, 303, 307, 308) and location:
            url = urljoin(url, location)
        else:
            print(f"     final status {r.status_code}")
            return
    print(f"     more than {max_hops} redirect hops")


if __name__ == "__main__":
    for start in sys.argv[1:]:
        for agent in AGENTS:  # different chains for the two user agents point to cloaking
            check(start, agent)

// Server (Express 4 or 5): static files first, then a final handler for every other path
const express = require('express');
const path = require('path');
const app = express();
const shell = path.join(__dirname, 'dist', 'index.html');
const notFound = path.join(__dirname, 'dist', '404.html'); // static error page: no router script
const PAGES = [/^\/$/, /^\/chairs\/$/, /^\/tables\/$/, /^\/about\/$/];
const PRODUCT = /^\/chairs\/([a-z0-9-]+)$/;

app.use(express.static(path.join(__dirname, 'dist'), { index: false }));

app.use(async (req, res) => {
  const product = req.path.match(PRODUCT);
  const found = PAGES.some((re) => re.test(req.path)) || (product !== null && (await productExists(product[1])));
  if (found) res.sendFile(shell);
  else res.status(404).sendFile(notFound); // also answers /not-found, the target of the client fallback
});

async function productExists(slug) {
  return ['oak-dining-chair', 'beech-stool'].includes(slug); // replace with your database or API lookup
}

app.listen(3000);

// Client fallback when the server cannot know: never leave a "not found" view on a 200 URL
fetch(`/api/products/${productId}`)
  .then((response) => response.json())
  .then((product) => {
    if (product.exists) {
      showProductDetails(product);
      return;
    }
    // Option 1: go to a URL whose server response is 404 (and whose page does not redirect again)
    window.location.replace('/not-found');
    // Option 2 (instead of option 1): keep the URL but keep the view out of the index
    // const robots = document.createElement('meta');
    // robots.name = 'robots';
    // robots.content = 'noindex';
    // document.head.appendChild(robots);
  });

<!-- The same block in the <head> of every language version listed here; the x-default target is a language selector page -->
<link rel="alternate" hreflang="en" href="https://www.example.com/en/chairs/">
<link rel="alternate" hreflang="en-GB" href="https://www.example.com/en-gb/chairs/">
<link rel="alternate" hreflang="de-DE" href="https://www.example.com/de-de/stuehle/">
<link rel="alternate" hreflang="de-AT" href="https://www.example.com/de-at/stuehle/">
<link rel="alternate" hreflang="de-CH" href="https://www.example.com/de-ch/stuehle/">
<link rel="alternate" hreflang="sv-SE" href="https://www.example.com/sv-se/stolar/">
<link rel="alternate" hreflang="zh-Hant" href="https://www.example.com/zh-hant/chairs/">
<link rel="alternate" hreflang="x-default" href="https://www.example.com/chairs/choose-language/">

<!-- Wrong values seen in the wild: "se", "dk", "cz" (country codes, not languages: use sv, da, cs),
     "en-UK" (use en-GB), "de-SW" (use de-CH), "en-EU" (no such region), "GB" (a region alone).
     A script subtag is valid: "zh-Hant", "zh-Hans-CN" (language, script, region in that order) -->

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
        xmlns:xhtml="http://www.w3.org/1999/xhtml">
  <url>
    <loc>https://www.example.com/en/chairs/</loc>
    <xhtml:link rel="alternate" hreflang="en" href="https://www.example.com/en/chairs/"/>
    <xhtml:link rel="alternate" hreflang="de-DE" href="https://www.example.com/de-de/stuehle/"/>
    <xhtml:link rel="alternate" hreflang="x-default" href="https://www.example.com/"/>
  </url>
  <url>
    <loc>https://www.example.com/de-de/stuehle/</loc>
    <xhtml:link rel="alternate" hreflang="en" href="https://www.example.com/en/chairs/"/>
    <xhtml:link rel="alternate" hreflang="de-DE" href="https://www.example.com/de-de/stuehle/"/>
    <xhtml:link rel="alternate" hreflang="x-default" href="https://www.example.com/"/>
  </url>
</urlset>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "@id": "https://www.example.com/chairs/oak-dining-chair#product",
  "name": "Oak dining chair with woven seat",
  "description": "Solid oak dining chair with a hand-woven paper-cord seat.",
  "image": [
    "https://www.example.com/img/oak-chair-1200.webp",
    "https://www.example.com/img/oak-chair-side-1200.webp"
  ],
  "sku": "CH-OAK-01",
  "brand": {
    "@type": "Brand",
    "name": "Example Shop"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://www.example.com/chairs/oak-dining-chair",
    "price": 149.00,
    "priceCurrency": "EUR",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition",
    "validFrom": "2026-11-27T00:00:00+01:00",
    "priceValidUntil": "2026-11-30T23:59:59+01:00",
    "priceSpecification": {
      "@type": "UnitPriceSpecification",
      "priceType": "https://schema.org/StrikethroughPrice",
      "price": 199.00,
      "priceCurrency": "EUR"
    },
    "shippingDetails": {
      "@type": "OfferShippingDetails",
      "hasShippingService": {
        "@id": "https://www.example.com/#standard-shipping"
      }
    },
    "hasMerchantReturnPolicy": {
      "@id": "https://www.example.com/#returns"
    }
  }
}
</script>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "OnlineStore",
  "@id": "https://www.example.com/#organization",
  "name": "Example Shop",
  "url": "https://www.example.com/",
  "logo": "https://www.example.com/img/logo-512.png",
  "sameAs": [
    "https://video.example.net/@exampleshop",
    "https://social.example.org/exampleshop"
  ],
  "hasMerchantReturnPolicy": {
    "@type": "MerchantReturnPolicy",
    "@id": "https://www.example.com/#returns",
    "applicableCountry": ["ES", "FR"],
    "returnPolicyCountry": "ES",
    "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
    "merchantReturnDays": 30,
    "returnMethod": "https://schema.org/ReturnByMail",
    "returnFees": "https://schema.org/FreeReturn",
    "refundType": "https://schema.org/FullRefund"
  },
  "hasShippingService": {
    "@type": "ShippingService",
    "@id": "https://www.example.com/#standard-shipping",
    "name": "Standard shipping to Spain and France",
    "fulfillmentType": "FulfillmentTypeDelivery",
    "handlingTime": {
      "@type": "ServicePeriod",
      "cutoffTime": "14:00:00+01:00",
      "duration": {
        "@type": "QuantitativeValue",
        "minValue": 0,
        "maxValue": 1,
        "unitCode": "DAY"
      },
      "businessDays": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
    },
    "shippingConditions": [
      {
        "@type": "ShippingConditions",
        "shippingDestination": [
          { "@type": "DefinedRegion", "addressCountry": "ES" },
          { "@type": "DefinedRegion", "addressCountry": "FR" }
        ],
        "orderValue": {
          "@type": "MonetaryAmount",
          "minValue": 0,
          "maxValue": 99.99,
          "currency": "EUR"
        },
        "shippingRate": {
          "@type": "MonetaryAmount",
          "value": 4.95,
          "currency": "EUR"
        },
        "transitTime": {
          "@type": "ServicePeriod",
          "duration": {
            "@type": "QuantitativeValue",
            "minValue": 2,
            "maxValue": 4,
            "unitCode": "DAY"
          }
        }
      },
      {
        "@type": "ShippingConditions",
        "shippingDestination": [
          { "@type": "DefinedRegion", "addressCountry": "ES" },
          { "@type": "DefinedRegion", "addressCountry": "FR" }
        ],
        "orderValue": {
          "@type": "MonetaryAmount",
          "minValue": 100,
          "currency": "EUR"
        },
        "shippingRate": {
          "@type": "MonetaryAmount",
          "value": 0,
          "currency": "EUR"
        },
        "transitTime": {
          "@type": "ServicePeriod",
          "duration": {
            "@type": "QuantitativeValue",
            "minValue": 2,
            "maxValue": 4,
            "unitCode": "DAY"
          }
        }
      }
    ]
  },
  "hasMemberProgram": {
    "@type": "MemberProgram",
    "name": "Example Club",
    "description": "Free membership: earn points on every order.",
    "url": "https://www.example.com/club/",
    "hasTiers": [
      {
        "@type": "MemberProgramTier",
        "@id": "https://www.example.com/club/#member",
        "name": "Member",
        "hasTierBenefit": ["https://schema.org/TierBenefitLoyaltyPoints"],
        "membershipPointsEarned": 5
      }
    ]
  }
}
</script>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "NewsArticle",
  "headline": "How to care for an oak dining table",
  "image": [
    "https://www.example.com/img/oak-care-1x1.webp",
    "https://www.example.com/img/oak-care-4x3.webp",
    "https://www.example.com/img/oak-care-16x9.webp"
  ],
  "datePublished": "2026-10-02T08:00:00+02:00",
  "dateModified": "2026-10-02T09:20:00+02:00",
  "author": [
    {
      "@type": "Person",
      "name": "Jane Doe",
      "url": "https://www.example.com/authors/jane-doe/"
    },
    {
      "@type": "Person",
      "name": "John Roe",
      "url": "https://www.example.com/authors/john-roe/"
    }
  ]
}
</script>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "NewsArticle",
  "headline": "How to care for an oak dining table",
  "datePublished": "2026-10-02T08:00:00+02:00",
  "isAccessibleForFree": false,
  "hasPart": {
    "@type": "WebPageElement",
    "isAccessibleForFree": false,
    "cssSelector": ".paywall"
  }
}
</script>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "WebSite",
  "name": "Example Shop",
  "alternateName": "ExShop",
  "url": "https://www.example.com/"
}
</script>

# https://www.example.com/robots.txt
User-agent: *
Disallow: /search?
Disallow: /cart/
Disallow: /checkout/
Disallow: /api/
Allow: /api/products/

# Google Shopping's crawler: same rules, but cart and checkout stay crawlable
User-agent: Storebot-Google
Disallow: /search?
Disallow: /api/
Allow: /api/products/

Sitemap: https://www.example.com/sitemap.xml

<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:g="http://base.google.com/ns/1.0">
  <channel>
    <title>Example Shop</title>
    <link>https://www.example.com/</link>
    <description>Example Shop product feed</description>
    <item>
      <g:id>KT-17-STEEL</g:id>
      <g:title>Steel kettle 1.7 l with temperature control</g:title>
      <g:description>Stainless steel kettle with five temperature settings and a keep-warm mode.</g:description>
      <g:link>https://www.example.com/kettles/steel-kettle-17</g:link>
      <g:image_link>https://www.example.com/img/steel-kettle-17-1200.jpg</g:image_link>
      <g:price>59.00 EUR</g:price>
      <g:availability>in_stock</g:availability>
      <g:condition>new</g:condition>
      <g:brand>Example Home</g:brand>
      <g:gtin>4006381333931</g:gtin>
      <g:product_highlight>Five temperature settings from 70 to 100 degrees Celsius</g:product_highlight>
      <g:product_highlight>Keeps water warm for up to 30 minutes</g:product_highlight>
      <g:product_detail>
        <g:section_name>General</g:section_name>
        <g:attribute_name>Capacity</g:attribute_name>
        <g:attribute_value>1.7 l</g:attribute_value>
      </g:product_detail>
      <g:product_detail>
        <g:section_name>Power</g:section_name>
        <g:attribute_name>Wattage</g:attribute_name>
        <g:attribute_value>2200 W</g:attribute_value>
      </g:product_detail>
      <g:question_and_answer>
        <g:question>Does the kettle switch off when it boils dry?</g:question>
        <g:answer>Yes. Boil-dry protection switches it off when there is no water in it.</g:answer>
      </g:question_and_answer>
      <g:question_and_answer>
        <g:question>Can I set it to 80 degrees for green tea?</g:question>
        <g:answer>Yes. The 80 degree setting is one of the five presets.</g:answer>
      </g:question_and_answer>
    </item>
  </channel>
</rss>

<figure>
  <picture>
    <source type="image/avif"
            srcset="/img/oak-chair-800.avif 800w, /img/oak-chair-1600.avif 1600w"
            sizes="(max-width: 800px) 100vw, 800px">
    <source type="image/webp"
            srcset="/img/oak-chair-800.webp 800w, /img/oak-chair-1600.webp 1600w"
            sizes="(max-width: 800px) 100vw, 800px">
    <img src="/img/oak-chair-800.jpg"
         srcset="/img/oak-chair-800.jpg 800w, /img/oak-chair-1600.jpg 1600w"
         sizes="(max-width: 800px) 100vw, 800px"
         alt="Oak dining chair with a woven paper-cord seat, seen from the front"
         width="800" height="600" loading="lazy">
  </picture>
  <figcaption>The oak dining chair in a natural oak finish, seat height 45 cm.</figcaption>
</figure>

<!-- Not indexable as an image: keep CSS backgrounds for decoration only -->
<div class="hero" style="background-image: url('/img/oak-chair-hero.jpg')"></div>

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
        xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">
  <url>
    <loc>https://www.example.com/chairs/oak-dining-chair</loc>
    <image:image>
      <image:loc>https://www.example.com/img/oak-chair-1200.webp</image:loc>
    </image:image>
    <image:image>
      <image:loc>https://www.example.com/img/oak-chair-side-1200.webp</image:loc>
    </image:image>
  </url>
</urlset>

<head>
  <meta name="robots" content="max-snippet:-1, max-image-preview:large">
  <meta property="og:image" content="https://www.example.com/img/oak-care-16x9.webp">
  <meta property="og:image:width" content="1600">
  <meta property="og:image:height" content="900">
  <meta property="og:image:alt" content="Hand applying oil to an oak table top">
</head>

<video controls preload="metadata" width="1280" height="720"
       poster="https://www.example.com/video/chair-assembly-1280.jpg">
  <source src="https://www.example.com/video/chair-assembly.mp4" type="video/mp4">
</video>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "VideoObject",
  "name": "How to assemble the oak dining chair",
  "description": "Step-by-step assembly of the oak dining chair in four minutes, with the tools you need.",
  "thumbnailUrl": ["https://www.example.com/video/chair-assembly-1280.jpg"],
  "uploadDate": "2026-09-15T09:00:00+02:00",
  "duration": "PT4M12S",
  "contentUrl": "https://www.example.com/video/chair-assembly.mp4",
  "embedUrl": "https://www.example.com/embed/chair-assembly",
  "hasPart": [
    {
      "@type": "Clip",
      "name": "Unpacking the parts",
      "startOffset": 0,
      "endOffset": 35,
      "url": "https://www.example.com/videos/chair-assembly?t=0"
    },
    {
      "@type": "Clip",
      "name": "Attaching the legs",
      "startOffset": 35,
      "endOffset": 140,
      "url": "https://www.example.com/videos/chair-assembly?t=35"
    },
    {
      "@type": "Clip",
      "name": "Fitting the seat",
      "startOffset": 140,
      "endOffset": 252,
      "url": "https://www.example.com/videos/chair-assembly?t=140"
    }
  ]
}
</script>

// back-button.spec.js: npm i -D @playwright/test, then npx playwright test
const { test, expect } = require('@playwright/test');

const START = 'https://www.example.com/'; // stands in for the page the user came from, such as a search results page
const PAGES = [
  'https://www.example.com/blog/oak-table-care/',
  'https://www.example.com/chairs/oak-dining-chair',
];

for (const url of PAGES) {
  test(`one Back press leaves ${url}`, async ({ page }) => {
    await page.goto(START);
    await page.goto(url);
    await page.keyboard.press('End'); // a real user input that also scrolls to the bottom
    await page.waitForTimeout(5000);  // give delayed scripts time to run
    await page.goBack();
    await expect(page).toHaveURL(START);
  });
}

grep -rnE "history\.(pushState|replaceState)|addEventListener\(.popstate" dist/

-- Top non-anonymized queries per page, web search, last 28 days
SELECT
  url,
  query,
  SUM(clicks) AS clicks,
  SUM(impressions) AS impressions,
  SAFE_DIVIDE(SUM(clicks), SUM(impressions)) AS ctr,
  SAFE_DIVIDE(SUM(sum_position), SUM(impressions)) + 1 AS avg_position
FROM `my-project.searchconsole.searchdata_url_impression`
WHERE search_type = 'WEB'
  AND data_date >= DATE_SUB(CURRENT_DATE(), INTERVAL 28 DAY)
  AND NOT is_anonymized_query
GROUP BY url, query
ORDER BY clicks DESC
LIMIT 1000;