---
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-05-09T23:44:18.419Z"
---

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

<table>
<thead>
  <tr>
    <th>
      Category
    </th>
    
    <th>
      Rules
    </th>
  </tr>
</thead>

<tbody>
  <tr>
    <td>
      Broken Links
    </td>
    
    <td>
      <code>
        no-error-response
      </code>
      
      , <code>
        missing-hash
      </code>
      
      , <code>
        redirects
      </code>
    </td>
  </tr>
  
  <tr>
    <td>
      SEO
    </td>
    
    <td>
      <code>
        no-uppercase-chars
      </code>
      
      , <code>
        no-underscores
      </code>
      
      , <code>
        trailing-slash
      </code>
      
      , <code>
        no-whitespace
      </code>
      
      , <code>
        no-non-ascii-chars
      </code>
    </td>
  </tr>
  
  <tr>
    <td>
      URL Structure
    </td>
    
    <td>
      <code>
        absolute-site-urls
      </code>
      
      , <code>
        no-baseless
      </code>
      
      , <code>
        no-double-slashes
      </code>
      
      , <code>
        no-duplicate-query-params
      </code>
    </td>
  </tr>
  
  <tr>
    <td>
      Accessibility
    </td>
    
    <td>
      <code>
        link-text
      </code>
      
      , <code>
        no-missing-href
      </code>
      
      , <code>
        no-javascript
      </code>
    </td>
  </tr>
</tbody>
</table>

## 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).

<table>
<thead>
  <tr>
    <th>
      Rule
    </th>
    
    <th>
      Description
    </th>
  </tr>
</thead>

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

### `absolute-site-urls`

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'
    ],
  },
})
```

</code-group>

### `link-text`

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'
    ],
  },
})
```

</code-group>

### `missing-hash`

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'
    ],
  },
})
```

</code-group>

### `no-baseless`

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'
    ],
  },
})
```

</code-group>

### `no-double-slashes`

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'
    ],
  },
})
```

</code-group>

### `no-duplicate-query-params`

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'
    ],
  },
})
```

</code-group>

### `no-error-response`

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 a match is found. External links require `fetchRemoteUrls: true` to be checked.

<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'
    ],
  },
})
```

</code-group>

### `no-javascript`

Checks for JavaScript links.

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

It's recommended to use a `<button type="button">` 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'
    ],
  },
})
```

</code-group>

### `no-missing-href`

Ensures that links have an `href` attribute.

Having an `href` attribute is required for links to be accessible and usable. If you need a an anchor that doesn't navigate, use a `<button>` 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'
    ],
  },
})
```

</code-group>

### `no-non-ascii-chars`

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'
    ],
  },
})
```

</code-group>

### `no-underscores`

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'
    ],
  },
})
```

</code-group>

### `no-uppercase-chars`

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'
    ],
  },
})
```

</code-group>

### `no-whitespace`

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'
    ],
  },
})
```

</code-group>

### `redirects`

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'
    ],
  },
})
```

</code-group>

### `trailing-slash`

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 trailing slashes are disabled, which is the default.

<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'
    ],
  },
})
```

</code-group>