How to automate image SEO audits for alt text, file size, and lazy loading

Last updated: October 13, 2026

Quick answer: for a 200-page site, you can often audit the main image issues in 1–2 hours with a crawl-plus-spreadsheet workflow. Use a crawler like Screaming Frog or Sitebulb for coverage, pair it with PageSpeed Insights or Lighthouse for loading behavior, then route the findings into a spreadsheet or ticketing system so only the exceptions need human review.

Key Takeaways

A 200-page site can still be checked manually when image volume is low.
Separate missing, weak, and intentionally empty alt text before you flag issues.
File bytes and displayed size both matter.
Check lazy loading in markup and in real browser behavior, because loading="lazy" alone is not proof.

What actually determines the right audit setup?

If you have a small site, a content-heavy blog, or a catalog that changes every week, the right setup is the one that catches obvious image problems without drowning you in false alarms. For a 200-page site, manual checks can still work. For a 2,000-page site with product variants, pagination, and CMS-generated image fields, manual review breaks down fast.

The key question is not “which tool is best?” It is “what do I need the audit to tell me?” If the answer is coverage, use a crawler. If the answer is performance, add Lighthouse or PageSpeed Insights. If the answer is content quality, build a rules-based alt text review on top. For accessibility criteria, see the W3C WCAG alt text guidance and Google Search Central’s image SEO advice.

Here is the basic split I recommend:

Situation	Best Path	Why Other Options Fail
Under 100 pages, few images	Manual spot checks plus Lighthouse	Full automation adds setup time you may not recoup
100–5,000 pages, recurring updates	Screaming Frog or Sitebulb crawl + spreadsheet rules	Manual audits miss drift and are too slow
Ecommerce with many variants	Crawl templates and image directories separately	Page-level checks miss duplicate or oversized assets
Editorial site with image-heavy posts	CMS export + crawl + alt text rules	CMS data alone does not show real output on the page

If you are choosing tools, I would start with Screaming Frog SEO Spider or Sitebulb for discovery, Google PageSpeed Insights for field lab checks, and a spreadsheet or Sheets script for sorting exceptions. Screaming Frog has a free crawl limit, but the paid plan is where recurring audits become practical; Sitebulb is a strong alternative if you want more built-in issue grouping. I am not naming a winner because pricing and feature tiers change, and that matters more than any generic list.

Define the audit scope: all indexable templates, or just key money pages.
Run a crawl that extracts image URLs, alt attributes, image dimensions, and file types.
Export image data to CSV and sort by page template, image size, and missing alt text.
Run a second pass with PageSpeed Insights or Lighthouse on representative templates, not every URL.
Turn the findings into rules: missing alt, duplicate alt, oversized files, and lazy-load failures.
Assign owners so the same issue does not keep reappearing after content updates.

A useful audit is not just a report. It is a repeatable decision tree. Quick check: if your site changes weekly or monthly, you need automation; if it changes once a quarter and has fewer than 100 images, a lighter workflow may be enough.

How do I automate alt text checks without creating garbage results?

You automate alt text checks by separating “missing,” “present but weak,” and “purposefully empty,” because those are not the same problem. An image with no alt at all is usually a miss. An image with alt="" may be correct if it is decorative. An image with “image,” “photo,” or a filename copied into the field is technically present but still poor.

This is where generic advice goes wrong: it treats every empty or short alt tag as an error. That creates bad tickets for decorative icons, spacer graphics, and decorative background-adjacent images. The better system uses rules, and for edge cases you should consult a professional accessibility specialist or editorial lead; see the W3C alt decision tree and WCAG 1.1.1.

For example, in Screaming Frog you can crawl images and export alt text fields. In Sitebulb, you can inspect image accessibility issues and group them by severity. If you use a CMS export, you can apply formulas in Excel or Google Sheets to flag:

blank alt on content images
alt that equals file name
alt that is too long to be useful
repeated alt text across different pages where the image context changes

A clean rule set is better than a “best practice” slogan. I would use these buckets:

Missing alt: image likely should have descriptive alt.
Decorative alt: empty alt allowed, but only for images that add no information.
Weak alt: phrases like “banner,” “graphic,” or “product image.”
Potential duplicate: same alt on many different images in different contexts.

A practical workflow looks like this:

Export all image URLs, alt attributes, page URLs, and page titles from your crawler.
Mark known decorative assets once, so they stop generating noise.
Flag blank alt only on content images, product images, and linked images.
Flag alt that repeats the filename or contains boilerplate terms like “image” or “photo.”
Review a sample of flagged rows by hand before sending fixes to editors or developers.
Store the approved rules in a shared checklist so the audit stays consistent next month.

One honest limitation: no automated system can fully judge intent. A screen reader and a human editor can tell whether the image is decorative, informative, or redundant. Automation should reduce the review set, not replace editorial judgment. Quick check: if your alt text issues are mostly obvious omissions, automate aggressively; if your site uses many decorative visuals, build a manual review layer before you alert anyone.

How do I catch oversized images and file-size problems at scale?

You catch oversized images by auditing both the file bytes and the rendered dimensions, because a 2 MB image that displays at 300 pixels wide is wasteful even if it looks fine. File size alone is not enough, and rendered size alone is not enough. You need both.

This matters most on pages with hero banners, product galleries, author headshots, and embedded article images. A typical crawl can tell you the image URL, size in bytes, and sometimes width and height. A page performance tool can tell you whether images are contributing to poor load times. The right threshold depends on the template and the device mix, but the basic principle does not: serve images close to the size they are displayed. For data context, Google’s 2024 Web Almanac reports that the median page weight is still in the multi-megabyte range, and PageSpeed Insights can show which image requests affect real template performance.

Here is the workflow I would use:

Crawl the site and export image byte size, dimensions, page URL, and image type.
Sort by largest files first, then compare each image to its displayed width on the page.
Flag any image that is much larger than its rendered slot, especially on mobile templates.
Check whether the site uses modern formats such as WebP or AVIF where supported.
Run PageSpeed Insights on the most image-heavy templates to see which assets delay Largest Contentful Paint.
Feed oversized-image findings into the CMS or asset pipeline so future uploads are constrained.

The trade-off is simple: compression and modern formats can reduce weight, but aggressive compression can blur text in images, product details, and charts. That is why I would not auto-compress everything blindly. A chart with small labels needs different handling from a lifestyle photo.

If you need a benchmark, keep it qualitative unless you have a team-agreed standard. Many teams use “as small as possible while still matching the display size and quality needs.” That sounds vague, but it is safer than pretending one universal kilobyte target fits every site. If you need a policy, write one by image type: product, editorial, icon, banner, infographic.

Quick check: if your site has a lot of hero images or product galleries, file-size automation is worth doing first; if most images are tiny icons or social share thumbnails, focus more on dimensions and format than raw bytes.

How do I automate lazy loading audits without breaking the page?

You automate lazy loading audits by checking both the HTML attribute and the actual loading behavior, because the presence of loading="lazy" does not guarantee the browser is using it well. Some images should be lazy-loaded. Some should not. The above-the-fold hero image is the classic exception.

The common mistake is to assume that more lazy loading always means better performance. It does not. If the main image on a page is lazy-loaded, you can hurt rendering and create a poor first impression. If every image is lazy-loaded, you can also delay content that should appear immediately. See Chrome’s lazy-loading guidance and web.dev on loading images.

I would automate lazy loading checks in three layers:

HTML inspection: is loading="lazy" applied where expected?
Template inspection: is the main hero or LCP image excluded from lazy loading?
Runtime inspection: do images actually load when they enter the viewport?

Lighthouse and PageSpeed Insights help here because they surface deferred image behavior and loading issues on real pages. Screaming Frog can show whether the markup contains the attribute, but it cannot tell you whether the browser experience is healthy in the same way a performance audit can.

A practical path looks like this:

Identify which template types have above-the-fold images, inline content images, and below-the-fold galleries.
Set a rule: lazy-load below-the-fold images, but exempt the LCP candidate and critical logos or masthead visuals.
Crawl the pages and export the `loading` attribute for image tags.
Compare the crawl data with PageSpeed Insights reports on the same templates.
Look for images that are marked lazy but still appear early, or images that load eagerly but sit far below the fold.
Hand the exceptions to the template owner, not just the content team, because lazy loading is often a front-end setting.

Who this is not for: if your site uses complex carousels, infinite scroll, or JavaScript-rendered galleries, simple crawl data may miss the real behavior. In that case, a browser-based audit using Chrome DevTools or a scripted test in Playwright gives you a truer picture than HTML alone.

Quick check: if your pages have one obvious hero image and many support images, lazy loading should be rule-based; if your layouts change heavily with JavaScript, you need runtime checks, not just markup scans.

What should the automation workflow look like end to end?

Because the audit needs both completeness and prioritization, the best workflow is a two-pass system: crawl for completeness, then score for priority. If you try to solve alt text, file size, and lazy loading in one pass, you get a pile of mixed findings that is hard to act on. If you split the process, the output becomes usable.

Here is the pattern I would set up for a normal marketing or ecommerce site:

Crawl the site with Screaming Frog, Sitebulb, or a similar crawler.
Export image-level data: page URL, image URL, alt text, byte size, dimensions, file type, and loading attribute.
Apply rule-based filters in Sheets, Excel, or a script.
Run a performance check on priority templates in Lighthouse or PageSpeed Insights.
Combine the results into one issue list with owner, severity, and fix type.
Push fixes into the CMS, design system, or asset pipeline.
Re-run the audit after deployment and compare only the deltas.

The part many teams miss is ownership. If alt text is managed by editors, oversized files by the media library, and lazy loading by frontend code, then one spreadsheet alone will not fix anything. The audit should produce separate queues. Otherwise the same issue comes back in the next content batch.

If you use automation well, you should be able to answer three questions quickly:

Which pages have missing or weak alt text?
Which images are too heavy for the space they occupy?
Which templates lazy-load the wrong images?

That is enough to get started. Anything beyond that is refinement.

Quick check: if your audit output cannot be handed to editors and developers as separate action lists, the workflow is too tangled.

What breaks the normal advice?

The normal advice breaks when the page type, CMS, or rendering model changes the meaning of the image itself. There are at least five cases where a simple rule set fails.

Situation: decorative icons in navigation.
What changes: blank alt may be correct, and flagging every empty alt becomes noise.
What to do instead: maintain a whitelist of approved decorative assets and exclude them from missing-alt alerts.
Situation: product images with text overlays or labels.
What changes: file size and compression matter less than legibility.
What to do instead: review compressed outputs manually and set a quality floor for this image type.
Situation: responsive images with srcset and sizes.
What changes: a single file-size number is misleading because the browser may choose different files at different viewports.
What to do instead: audit the source set and test representative breakpoints in Lighthouse or Chrome DevTools.
Situation: JavaScript-rendered galleries or lazy-loaded infinite scroll.
What changes: a crawler may not see the same DOM that users see.
What to do instead: run browser-based audits with Playwright, Puppeteer, or DevTools recordings.
Situation: translated sites.
What changes: alt text quality depends on locale, not just presence.
What to do instead: audit per language and avoid treating translated duplicates as a single content set; if the locale workflow is sensitive, consult an international SEO or accessibility specialist and compare against Google’s localized content guidance.
Situation: legal, medical, or technical diagrams.
What changes: alt text must convey meaning precisely, not just describe appearance.
What to do instead: route those images to subject-matter review even if the automation says they “pass.”

That is the trade-off I would state plainly:

Drafted with AI; not yet reviewed by a person.