The Comprehensive Astro SEO Checklist
Astro ships fast HTML by default, but fast isn't the same as optimized. This checklist covers every SEO consideration specific to Astro 4.x+ — from Islands to View Transitions to content collections.
The comprehensive Astro SEO checklist
Astro gets the hard part right by default — it ships zero JavaScript to the browser unless you explicitly opt in. That puts you ahead of most React-based frameworks on Core Web Vitals before you write a single line of optimization code. But fast pages aren't automatically well-optimized pages. Metadata pipelines, structured data, sitemap generation, internal linking, and crawlability all need deliberate attention.
This checklist covers the SEO considerations specific to Astro 4.x and later. If you already know your way around astro.config.mjs, this should feel like a peer review of your setup rather than a tutorial.
Why Astro sites still need SEO auditing
Astro's architecture — static-first with selective hydration via Islands — eliminates many of the SEO problems that plague client-side-rendered frameworks. There's no hydration mismatch, no empty-HTML-on-first-paint issue, no JavaScript rendering dependency for search crawlers.
But Astro introduces its own set of considerations that don't exist in traditional server-rendered frameworks. View Transitions can create crawl ambiguity. Content collections abstract away URL structure in ways that may or may not match your information architecture. The @astrojs/sitemap integration requires configuration to produce a useful XML sitemap rather than a dump of every route.
If you're auditing an Astro site for the first time — or inheriting one — a framework-specific checklist catches issues that a generic technical SEO audit guide would miss. For a broader perspective on auditing framework-built sites, start with the website audit checklist for agencies.
Prerequisites
- An Astro 4.x+ project (this checklist assumes the current stable API)
- Access to Google Search Console for the deployed site
- Familiarity with
astro.config.mjsand Astro's file-based routing - Optionally, an Evergreen account for automated auditing — the free plan covers up to 500 pages
The checklist
1. Verify every page has a unique title and meta description
Astro doesn't enforce metadata. If your layout component doesn't set <title> and <meta name="description"> from page-level frontmatter, every page inherits the same defaults — or gets nothing.
---
// src/layouts/BaseLayout.astro
const { title, description } = Astro.props;
---
<html lang="en">
<head>
<title>{title}</title>
<meta name="description" content={description} />
</head>
<body>
<slot />
</body>
</html>
Check that every page passes unique title and description props. A site-wide crawl that surfaces pages with missing meta descriptions catches the gaps faster than manual spot-checking.
2. Set canonical URLs
Astro 4.x provides Astro.url and Astro.site for building canonical URLs. Set site in your config so canonical URLs resolve to the correct domain:
// astro.config.mjs
export default defineConfig({
site: "https://example.com",
})
Then in your layout:
<link rel="canonical" href={Astro.url.href} />
Without site configured, Astro.url resolves to localhost during development and may produce incorrect canonicals in static builds if your deployment URL differs from what Astro infers.
3. Configure the sitemap integration
The @astrojs/sitemap integration generates an XML sitemap at build time. Install and configure it:
// astro.config.mjs
import sitemap from "@astrojs/sitemap"
export default defineConfig({
site: "https://example.com",
integrations: [sitemap()],
})
By default, it includes every static route. Use the filter option to exclude pages that shouldn't be indexed (admin panels, draft pages, utility routes):
integrations: [
sitemap({
filter: (page) =>
!page.includes('/admin/') &&
!page.includes('/draft/'),
}),
],
Verify the output at /sitemap-index.xml after building. Submit it in Google Search Console.
4. Audit your content collections for URL consistency
Astro's content collections are powerful but abstract away the relationship between file structure and URL structure. A collection defined in src/content/blog/ doesn't automatically produce URLs at /blog/ — that depends on how you generate pages in src/pages/.
Check that:
- Every collection entry has a corresponding route
- The slug derivation matches your intended URL structure
- No entries produce duplicate or near-duplicate URLs
- Draft entries are excluded from production builds
5. Handle Islands and hydration directives correctly
Astro Islands — interactive components hydrated with directives like client:load, client:visible, or client:idle — are invisible to search crawlers in their pre-hydration state. This is fine for interactive widgets, but if an Island contains content that should be indexed (unlikely, but possible), that content won't appear in the static HTML.
Rule of thumb: Content that needs to be crawled should live in the Astro template, not inside a client-side Island. Interactive behavior wraps around content — it doesn't contain it.
Check your Islands for:
- Content that should be in the static HTML but is rendered only after hydration
client:onlydirectives (these render nothing server-side — the component is fully client-rendered)- Excessive use of
client:loadwhereclient:idleorclient:visiblewould reduce initial JavaScript
6. Evaluate View Transitions for crawl implications
Astro's View Transitions provide smooth page-to-page animations using the browser's View Transitions API with a fallback for unsupported browsers. From a user perspective, the site feels like a SPA. From a crawl perspective, each page is still a full static HTML document.
This is generally good for SEO — crawlers see full HTML. But verify:
- The fallback for browsers without View Transitions API support renders the same content (it should, since Astro's implementation is progressive enhancement)
- Navigation between pages doesn't rely on client-side routing that could break if JavaScript fails
<ViewTransitions />in your layout head doesn't conflict with any custom<meta>tag management
7. Implement structured data
Astro doesn't include structured data tooling out of the box. Add JSON-LD manually or via a component:
---
// src/components/StructuredData.astro
const { data } = Astro.props;
---
<script type="application/ld+json" set:html={JSON.stringify(data)} />
At minimum, implement:
WebSiteschema on the homepageArticleorBlogPostingschema on content pagesBreadcrumbListschema if you have breadcrumb navigation
Test with Google's Rich Results Test after deployment.
8. Set up proper heading hierarchy
Astro's component model makes it easy to accidentally nest headings incorrectly. A layout component might render an <h1>, and a child component might render another <h1> inside a section — producing two H1s on the same page.
Audit every page for:
- Exactly one
<h1>per page - No skipped heading levels (no
<h3>directly under an<h1>) - Headings that describe the content beneath them, not decorative use of heading tags for styling
9. Optimize images with the built-in Image component
Astro 4.x includes a built-in <Image /> component that handles responsive sizing, format conversion (to WebP/AVIF), and lazy loading:
---
import { Image } from 'astro:assets';
import heroImage from '../assets/hero.jpg';
---
<Image src={heroImage} alt="Description of the image" />
Check that:
- All above-the-fold images use
loading="eager"(the default for<Image />is lazy) - All images have descriptive
altattributes - Images imported from
src/assets/are processed at build time (images inpublic/are not optimized)
10. Verify robots.txt and indexability
Create a public/robots.txt that references your sitemap:
User-agent: *
Allow: /
Sitemap: https://example.com/sitemap-index.xml
Then verify that no pages are accidentally blocked. Check for noindex tags on pages that should be indexed — a common issue when development noindex directives survive into production builds.
11. Confirm trailing slash behavior
Astro's trailingSlash config option ('always', 'never', or 'ignore') affects URL generation site-wide. Inconsistent trailing slash behavior creates duplicate content — /blog/post and /blog/post/ as separate URLs.
// astro.config.mjs
export default defineConfig({
trailingSlash: "never", // or 'always' — pick one and commit
})
Make sure your canonical URLs, internal links, and sitemap all use the same convention.
12. Audit internal linking depth
Astro's file-based routing doesn't guarantee good internal linking. A page at /resources/guides/advanced/topic exists four clicks from the homepage unless you've deliberately linked to it from higher-level pages.
Check that:
- No important page is more than three clicks from the homepage
- Content collection pages link to related entries
- Navigation and breadcrumbs surface deep content
13. Run site-wide Lighthouse
A single Lighthouse run on the homepage doesn't represent the site. Run bulk Lighthouse testing across all pages to find the ones where third-party scripts, unoptimized images, or layout shifts drag down performance.
Astro sites typically score well on Performance and Best Practices. The categories to watch are Accessibility (often neglected in component libraries) and SEO (metadata completeness).
How to interpret your audit results
After running through the checklist, group findings into three categories:
Template-level issues — problems that affect every page using a particular layout (missing canonical tags, no structured data, incorrect heading hierarchy). Fix these once in the layout component and every page benefits.
Content-level issues — problems specific to individual pages (missing meta descriptions, thin content, orphaned pages with no internal links). These require per-page attention, prioritized by traffic.
Configuration issues — problems in astro.config.mjs or deployment settings (wrong site URL, inconsistent trailing slashes, sitemap excluding important pages). These are one-time fixes with site-wide impact.
Prioritize configuration issues first (highest leverage), template issues second, and content issues third. For large Astro sites, the content-level issues are best handled with a filterable audit surface rather than a manual page-by-page review.
How Evergreen automates Astro site auditing
Evergreen crawls your deployed Astro site and populates an audit table with per-page data — title, meta description, H1, word count, internal links, Lighthouse performance scores, and indexability status. Every item on this checklist that involves finding pages with issues (missing metadata, noindex tags, thin content, performance problems) becomes a filter operation instead of a manual review.
The visual sitemap shows your Astro site's structure as a hierarchy, color-coded by the health metric you choose. Orphaned pages — content collection entries that nothing links to — stand out immediately.
On the Pro plan, daily syncs re-crawl and update the data automatically, so you see when a new deployment introduces issues before they affect rankings.
Audit your Astro site → Start free
Frequently asked questions
Is Astro better for SEO than Next.js?
Astro ships zero JavaScript by default, which gives it a Core Web Vitals advantage on content-heavy sites. Next.js 15+ with the App Router ships more JavaScript but offers server components and streaming SSR for dynamic content. For static content sites (blogs, documentation, marketing pages), Astro typically produces faster pages with less configuration. For dynamic applications with authenticated content, Next.js is the more natural fit. The Next.js SEO audit checklist covers the framework-specific considerations there.
Do Astro Islands hurt SEO?
No, as long as the indexable content lives in the static Astro template, not inside the Island component. Islands are rendered client-side after hydration — search crawlers see the pre-hydration HTML. Keep text content in Astro components and use Islands only for interactive behavior.
Does Astro handle dynamic rendering for social media previews?
Astro generates static HTML at build time, which includes all Open Graph and Twitter meta tags you define in your layout. Social media crawlers (Facebook, Twitter, LinkedIn) read these tags from the static HTML without executing JavaScript, so previews work correctly as long as the tags are present in the <head>.
How often should I re-audit an Astro site?
After every major content update or dependency upgrade. Astro's rapid release cycle (minor versions every few weeks) occasionally changes default behavior — particularly around image handling, content collections, and View Transitions. A monthly automated crawl catches regressions before they compound.
Your next step: see your Astro site's full audit data → Create free account
Related Topics in The Technical SEO Audit Guide
The Technical SEO Checklist for 2026
A practical technical SEO checklist covering crawlability, indexation, Core Web Vitals, structured data, JavaScript rendering, and AI search visibility — updated for 2026.
How to Find and Fix All Broken Links on Your Site
A practical guide to finding, prioritizing, and fixing broken links across your website to improve user experience and SEO performance.
The Complete Website Audit Checklist for Agencies (2026)
A 25-point website audit checklist built for agencies managing multiple client sites. Covers structure, content, performance, and reporting workflows.
How to Run a Bulk Lighthouse Test on Your Entire Site
Stop testing one page at a time. Run Lighthouse across your entire site to find the pages dragging down performance — and fix them systematically.
Next.js SEO Audit Checklist for 2026
An auditor's checklist for Next.js 14+ sites built on the App Router. Covers metadata, rendering strategies, dynamic routes, and the technical pitfalls that don't show up in generic SEO guides.
How to Find Noindex Pages Blocking Your Rankings
Accidental noindex tags silently remove pages from Google. Here's how to find every noindex directive on your site — and tell the intentional ones from the mistakes.
Technical SEO Audit Guide for Headless Websites
Headless websites separate content from presentation, and that separation introduces SEO audit challenges that monolithic sites don't have. This guide covers the methodology for auditing any headless stack.
Lighthouse Score for Your Entire Site: Tools and Methods
Lighthouse tests one page at a time. Here are five ways to get scores for every page on your site — from free CLI tools to SaaS dashboards — and when each approach makes sense.
Automated SEO Monitoring: Set Up Daily Site Audits
One-off audits find problems after they've already cost you traffic. Continuous monitoring finds them as they happen. Here's how to set up daily automated SEO monitoring that catches regressions before rankings suffer.
Shareable SEO Reports: How to Send Audits Clients Actually Read
Most SEO reports are PDFs that clients download, glance at, and forget. Shareable URL-based reports stay current, require no login, and get acted on. Here's why and how.
JavaScript Rendering Audit Checklist
A checklist for auditing JavaScript-rendered pages: crawl accessibility, metadata after render, lazy-loaded content, and the tools to verify what Google actually sees.
