# Run an SEO Audit on a Nuxt App

Yes. An agent builds your Nuxt app, serves it, crawls the rendered HTML for titles, descriptions, canonicals and Open Graph tags, and maps each gap to its page file.

[Run this on Rush](https://cloud.getrush.ai/run/seo-audit/nuxt/). Opens the console with this prompt ready to send, in a Project that has your repository.

## What the agent does

The agent reads how the app sets its head before it fetches a page. In a Nuxt app like nuxt/movies, `app/app.vue` calls `useHead` once for the whole site: `htmlAttrs.lang` from the i18n locale, a `title` of `Nuxt Movies` with a `titleTemplate` that appends the site name, one `description`, an `og:image` pointing at `social-card.png`, and `twitter:card`, `twitter:site` and `twitter:creator`. That is the inheritance every page starts from, and it is where the agent notes what is missing for all of them at once: no `og:title`, no `og:description`, no `og:url` and no canonical link anywhere in the app.

Then it reads each page under `app/pages`. `[type]/[id].vue` and `person/[id].vue` set a title, a `description` from the TMDB overview or biography, and an `og:image` built with `useImage` at 1200 by 630; `[type]/index.vue` sets a title and nothing else; `search.vue` sets a computed `Search: ...` title; `genre/[no]/movie.vue`, `genre/[no]/tv.vue` and `[type]/category/[query].vue` call `useHead` not at all, so a genre page ships with the site-wide title and the site-wide description. `nuxt.config.ts` adds two facts the crawl must account for: `routeRules` sends `cache-control: private, no-store` on `/**`, and `@nuxtjs/i18n` runs with `strategy: 'no_prefix'` and a language cookie across fourteen locales, so one URL serves fourteen languages and no `hreflang` can describe it. `public/robots.txt` allows everything and names no sitemap, and no sitemap module is installed.

With that map the agent runs the app the way CI does: `pnpm install`, `pnpm build`, then `node .output/server/index.mjs`, which serves server-rendered HTML with data from the `movies-proxy.vercel.app` proxy the config names. It fetches the home page, both `/movie` and `/tv` indexes, a movie and a TV detail page, a person page, a genre page, a category page and the search page, and parses each response for `<title>`, `meta[name=description]`, `link[rel=canonical]`, the `og:` and `twitter:` properties, the `lang` attribute, the single `h1`, image `alt` text on `MediaHero` and `MediaCard`, and the status code. Because `@nuxtjs/html-validator` is in the modules list with `failOnError: false`, it also reads what the validator reported during the build rather than re-running one.

Each finding is tied to the file that produces it: a missing `og:title` to `app/app.vue`, a genre page with a generic description to `app/pages/genre/[no]/movie.vue`, an `og:image` that points at a poster rather than a backdrop to the `$img` call in `[type]/[id].vue`, the absent sitemap to `nuxt.config.ts` and `public/robots.txt`. Where a fix is a few lines, the report shows the `useHead` block to add; where it is a product decision, such as prefixing locales so each language gets its own URL, it says what the decision costs.

## Start it with one API call

`POST https://api.phoenix.so/o/{org}/sessions`

```json
{
  "agent": "claude",
  "input": "Audit this Nuxt app for technical SEO and write seo-audit.md. Read nuxt.config.ts (modules, routeRules, i18n strategy), app/app.vue and every useHead and definePageMeta call under app/pages first, and public/robots.txt, so you know what each page inherits and what it sets. Install with pnpm using the lockfile, run pnpm build and start the production server from .output. Fetch the home page, each media index, one movie, one TV show, one person, one genre, one category and the search page with plain HTTP, no browser, and record the status, title, description, canonical, og and twitter tags, html lang, h1 and image alt text of each. Report, per page, what is missing or duplicated and the file and line that would fix it, and once for the site: the lack of canonical and og:title, the no_prefix locale strategy and its effect on hreflang, the absence of a sitemap, and the cache-control route rule. Include the html-validator output from the build. Change no code; the report is the result.",
  "resources": [
    {
      "url": "https://github.com/your-org/your-app"
    }
  ]
}
```

1. **Get an API key.** In the console, open Settings, then API keys, and create a key for your org. Send it in the Authorization header as a Bearer token.
2. **Send the request.** POST the body in request.json to https://api.phoenix.so/o/{org}/sessions, with your repository as the resources URL. The run starts in its own cloud sandbox.
3. **Read what came back.** Follow the run on its live stream or wait for the run.completed webhook, then read the result and its trajectory.

## What comes back

What comes back is `seo-audit.md` as an artifact on the session, with a table of the pages fetched and, for each, its status code, title, description, canonical, Open Graph and Twitter tags, `lang`, `h1` and any image without `alt`. Below the table, one section per finding names the page file and the `useHead` call or missing call behind it, with the lines to add, and a site-wide section covers the head defaults in `app/app.vue`, robots and sitemap, the locale strategy and the cache-control rule.

The report ends with the `html-validator` output captured from the build and the exact commands the agent ran, so a reader can rebuild and refetch the same pages. The repository is unchanged; a follow-up run with a different prompt can turn the agreed fixes into a pull request.

A reviewer checks the per-page table against the pages they care about, decides which findings are worth a change, and keeps the rest as a record of what was deliberate, such as the private cache rule on a site whose content changes per cookie.

## Run it on every merge to main

Add an automation to the Project with this prompt and a `github` trigger on `pull_request.closed.merged`, with `branch_patterns` set to `main`, so each merged pull request gets an audit of the rendered head on the new code. The event is added after the prompt as untrusted data; the agent reads the repository as it is after the merge. Mark the automation `read_only`, because a report changes nothing.

For a site that changes rarely, a `schedule` trigger with `every` set to `1d` or a weekly `cron`, read in your `timezone`, produces the same report on a cadence. From your own server, `POST /o/{org}/sessions` with the repository in `resources` starts one, and the artifact's `url` on the finished session downloads the report for an hour without a key.

## Why run it on Rush?

The honest way to audit a Nuxt app is to look at the HTML the server sends, not at the components, because `useHead` calls inherit, override and sometimes never run. That takes a production build and a running server, and for an app that fetches from an external proxy it takes network access during the crawl; a laptop mid-task is a poor place for either. The sandbox builds, serves and fetches, and the transcript keeps every response.

Each run reads the same pages the same way, so the report after a change can be set beside the one before it. The findings carry file paths and the lines to add, which is what makes them a pull request later rather than a list of complaints.

## Frequently asked questions

### Does the audit run Lighthouse?

No. This report is about what the HTML says: titles, descriptions, canonicals, Open Graph tags, `lang`, headings and alt text, plus robots and sitemap. It fetches pages with plain HTTP and needs no browser. A performance audit with Lighthouse is a separate job with its own page.

### The app serves fourteen languages at the same URLs. What does the report say about that?

It names the `strategy: 'no_prefix'` setting and the language cookie in `nuxt.config.ts`, explains that a crawler sees one language per URL and that `hreflang` cannot describe cookie-selected content, and sets out what switching to a prefixed strategy would change, including every internal link. It does not make that choice for you.

### What about the cache-control route rule?

`routeRules` sends `private, no-store` on every path, which keeps a CDN from caching pages whose content depends on the language cookie. The report records it as a finding with that reasoning, so a reader can decide whether the rule was deliberate, rather than treating it as a mistake.

### Does it need a TMDB key?

Not for this app: `app/composables/tmdb.ts` and `nuxt.config.ts` point at the public `movies-proxy.vercel.app` proxy, which holds the key, so the sandbox renders real pages. An app that calls an API directly needs its key as a Project secret, which the agent reads as an environment variable.

## More Nuxt jobs

- [Add Missing Tests to Every Pull Request in a Nuxt App](https://getrush.ai/run/test-every-pull-request/nuxt/)
- [Translate a Nuxt App Into Another Language](https://getrush.ai/run/translate-app-strings/nuxt/)
- [Upgrade Nuxt Dependencies Every Week](https://getrush.ai/run/upgrade-dependencies-weekly/nuxt/)

## The same job on other stacks

- [Run an SEO Audit on a Starlight Site](https://getrush.ai/run/seo-audit/starlight/)
- [Run an SEO Audit on an Astro Site](https://getrush.ai/run/seo-audit/astro/)
- [Run an SEO Audit on a Gatsby Blog](https://getrush.ai/run/seo-audit/gatsby/)

## Keep reading

- [How a Rush run works on your repository, from request to pull request](https://getrush.ai/cloud/)
- [Compare cloud agents, agent sandboxes and AI code review](https://getrush.ai/compare/)
- [Rush pricing: Free, Pro and Max](https://getrush.ai/pricing/)
