---
title: "Inspection Rules"
description: "Find out what rules are run when checking your links and why they exist."
canonical_url: "https://nuxtseo.com/docs/link-checker/guides/rules"
last_updated: "2026-08-19T10:49:45.397Z"
---

The module runs 15 inspections covering broken links, SEO best practices, and accessibility. To disable any rule, add it to `skipInspections` in your config.

## Rule Categories

| Category      | Rules                                                                                           |
| ------------- | ----------------------------------------------------------------------------------------------- |
| Broken Links  | `no-error-response`, `missing-hash`, `redirects`                                                |
| SEO           | `no-uppercase-chars`, `no-underscores`, `trailing-slash`, `no-whitespace`, `no-non-ascii-chars` |
| URL Structure | `absolute-site-urls`, `no-baseless`, `no-double-slashes`, `no-duplicate-query-params`           |
| Accessibility | `link-text`, `no-missing-href`, `no-javascript`                                                 |

## Disabling Rules

To disable any rule, add it to `skipInspections`:

```ts
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: ['rule-name']
  }
})
```

## Available Rules

Rules are based on the [URL structure best practices for Google](https://developers.google.com/search/docs/crawling-indexing/url-structure).

| Rule                                                                 | Description                                      |
| -------------------------------------------------------------------- | ------------------------------------------------ |
| [`absolute-site-urls`](#absolute-site-urls){lang="ts"}               | Checks for absolute links that are internal.     |
| [`link-text`](#link-text){lang="ts"}                                 | Ensures link text is descriptive and meaningful. |
| [`missing-hash`](#missing-hash){lang="ts"}                           | Checks for missing hashes in internal links.     |
| [`no-baseless`](#no-baseless){lang="ts"}                             | Checks for document relative links.              |
| [`no-double-slashes`](#no-double-slashes){lang="ts"}                 | Checks for double slashes in URLs.               |
| [`no-duplicate-query-params`](#no-duplicate-query-params){lang="ts"} | Checks for duplicate query parameters in URLs.   |
| [`no-error-response`](#no-error-response){lang="ts"}                 | Checks for error responses (4xx, 5xx) on links.  |
| [`no-javascript`](#no-javascript){lang="ts"}                         | Checks for JavaScript links.                     |
| [`no-missing-href`](#no-missing-href){lang="ts"}                     | Ensures that `a` tags have an `href` attribute.  |
| [`no-non-ascii-chars`](#no-non-ascii-chars){lang="ts"}               | Checks for non-ASCII characters.                 |
| [`no-underscores`](#no-underscores){lang="ts"}                       | Checks for underscores.                          |
| [`no-uppercase-chars`](#no-uppercase-chars){lang="ts"}               | Checks for uppercase characters.                 |
| [`no-whitespace`](#no-whitespace){lang="ts"}                         | Checks for whitespace.                           |
| [`redirects`](#redirects){lang="ts"}                                 | Warns when links respond with 301/302 redirects. |
| [`trailing-slash`](#trailing-slash){lang="ts"}                       | Checks for trailing slashes on internal links.   |

### `absolute-site-urls`{lang="ts"}

Checks for absolute links that are internal

Using relative paths is recommended as it makes your site more portable and easier to maintain.

::code-group
```html [❌ Invalid]
<NuxtLink to="https://example.com/about">my page</NuxtLink>
```

```html [✅ Valid]
<NuxtLink to="/about">my page</NuxtLink>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'absolute-site-urls'
    ],
  },
})
```
::

### `link-text`{lang="ts"}

Ensures link text is descriptive and meaningful.

Descriptive link text [provide improved accessibility](https://usability.yale.edu/web-accessibility/articles/links#link-text), allowing screen readers to better understand the context of the link.
It flags non-descriptive link text such as "click here", "click this", "this", "learn more", "go", "here", "start", "right here", "more", and similar.

::code-group
```html [❌ Invalid]
<NuxtLink to="/about">click here</NuxtLink>
```

```html [✅ Valid]
<NuxtLink to="/about">About</NuxtLink>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'link-text'
    ],
  },
})
```
::

### `missing-hash`{lang="ts"}

Checks for missing [Document Fragments](https://developer.mozilla.org/en-US/docs/Learn/HTML/Introduction_to_HTML/Creating_hyperlinks#document_fragments) for internal links.

Having valid hashes ensures that users are navigated to the correct section of the page, improving the user experience and accessibility.

::code-group
```html [❌ Invalid]
<div id="valid-anchor"></div>
<NuxtLink to="#valid">my page</NuxtLink>
```

```html [✅ Valid]
<div id="valid"></div>
<NuxtLink to="#valid">my page</NuxtLink>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'missing-hash'
    ],
  },
})
```
::

### `no-baseless`{lang="ts"}

Document relative links are valid but can cause SEO maintenance issues when moving around your content.

It's recommended to use root relative links to avoid these issues.

::code-group
```html [❌ Invalid]
<NuxtLink to="link">my page</NuxtLink>
```

```html [✅ Valid]
<NuxtLink to="/link">my page</NuxtLink>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'no-baseless'
    ],
  },
})
```
::

### `no-double-slashes`{lang="ts"}

Checks for double slashes in URLs.

Double slashes in URLs can cause canonicalization issues and can lead to duplicate content.

::code-group
```html [❌ Invalid]
<NuxtLink to="/link//">my page</NuxtLink>
```

```html [✅ Valid]
<NuxtLink to="/link/">my page</NuxtLink>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'no-double-slashes'
    ],
  },
})
```
::

### `no-duplicate-query-params`{lang="ts"}

Checks for duplicate query parameters in URLs.

Duplicate query parameters can cause issues with caching and can lead to duplicate content.

::code-group
```html [❌ Invalid]
<NuxtLink to="/link?param=1&param=2">my page</NuxtLink>
```

```html [✅ Valid]
<NuxtLink to="/link?param=1">my page</NuxtLink>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'no-duplicate-query-params'
    ],
  },
})
```
::

### `no-error-response`{lang="ts"}

Checks for error responses [(4xx, 5xx)](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status) on links.

Ensuring that links do not lead to error responses improves the user experience and improves
your sites crawlability. For internal links, the module will suggest similar pages when it finds a match. Checking external links requires `fetchRemoteUrls: true`.

::code-group
```html [Invalid]
<NuxtLink to="/broken-link">my page</NuxtLink>
```

```html [Valid]
<NuxtLink to="/valid-link">my page</NuxtLink>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'no-error-response'
    ],
  },
})
```
::

### `no-javascript`{lang="ts"}

Checks for JavaScript links.

JavaScript links provide poor user experience as they override the default browser behavior.

It's recommended to use a `<button type="button">`{lang="html"} if you need an on click event.

::code-group
```html [Invalid]
<a href="javascript:doSomething()">my page</a>
```

```html [Valid]
<button type="button" @click="doSomething()">my page</button>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'no-javascript'
    ],
  },
})
```
::

### `no-missing-href`{lang="ts"}

Ensures that links have an `href` attribute.

Links need an `href` attribute for accessibility and usability. If you need an anchor that doesn't navigate, use a `<button>`{lang="html"} instead
or the `role="button"` attribute.

::code-group
```html [Invalid]
<a>my page</a>
```

```html [Valid]
<a href="/link">my page</a>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'no-missing-href'
    ],
  },
})
```
::

### `no-non-ascii-chars`{lang="ts"}

Checks for non-ASCII characters in URLs.

Non-ASCII characters can cause issues with encoding and can lead to broken links.

::code-group
```html [Invalid]
<NuxtLink to="/my-ページ">my page</NuxtLink>
```

```html [Valid]
<NuxtLink to="/my-page">my page</NuxtLink>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'no-non-ascii-chars'
    ],
  },
})
```
::

### `no-underscores`{lang="ts"}

Checks for underscores in URLs.

Underscores are not recommended in URLs as they can cause issues with readability and SEO.

::code-group
```html [Invalid]
<NuxtLink to="/my_page">my page</NuxtLink>
```

```html [Valid]
<NuxtLink to="/my-page">my page</NuxtLink>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'no-underscores'
    ],
  },
})
```
::

### `no-uppercase-chars`{lang="ts"}

Checks for uppercase characters in URLs.

Uppercase characters are not recommended in URLs as they can cause issues with readability and SEO.

::code-group
```html [Invalid]
<NuxtLink to="/MyPage">my page</NuxtLink>
```

```html [Valid]
<NuxtLink to="/my-page">my page</NuxtLink>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'no-uppercase-chars'
    ],
  },
})
```
::

### `no-whitespace`{lang="ts"}

Checks for whitespace in URLs.

Whitespace in URLs can cause issues with encoding and can lead to broken links.

::code-group
```html [Invalid]
<NuxtLink to="/my page">my page</NuxtLink>
```

```html [Valid]
<NuxtLink to="/my-page">my page</NuxtLink>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'no-whitespace'
    ],
  },
})
```
::

### `redirects`{lang="ts"}

Warns when a link responds with a 301 or 302 redirect.

Redirects use up your crawl budget and increase loading times. It's recommended to link directly to the final URL when possible.

::code-group
```html [Invalid]
<!-- Links to a URL that redirects to /new-page -->
<NuxtLink to="/old-page">my page</NuxtLink>
```

```html [Valid]
<NuxtLink to="/new-page">my page</NuxtLink>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'redirects'
    ],
  },
})
```
::

### `trailing-slash`{lang="ts"}

Checks that internal links all either have or don't have a trailing slash depending on your configuration.

Inconsistent trailing slashes can cause issues with canonicalization and can lead to duplicate content.

The behavior depends on the `siteConfig.trailingSlash` setting. The example below assumes the default setting, with trailing slashes disabled.

::code-group
```html [Invalid]
<!-- trailing slashes disabled (default) -->
<NuxtLink to="/my-page/">my page</NuxtLink>
```

```html [Valid]
<NuxtLink to="/my-page">my page</NuxtLink>
```

```ts [Disable Inspection]
export default defineNuxtConfig({
  linkChecker: {
    skipInspections: [
      'trailing-slash'
    ],
  },
})
```
::