All jobs

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 RushOpens 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 with this body:

{
  "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.

The use case this job follows, with its automation and trigger: Produce a report or file, no repo.

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

The same job on other stacks

Keep reading