AI Landing Page Analysis

AI landing page analysis starts with a screenshot. The API captures any page as an image and hands it to a vision model like GPT-4o or Claude. One API call for the capture, one for the analysis. You get back structured scores on layout, copy, CTAs, trust signals. The whole thing takes a few seconds and costs less than a cent. Vision models can't visit URLs on their own (for the full technical picture, see the screenshots for AI agents page). They need the rendered image. That's what the screenshot API provides.

Why a screenshot beats raw HTML for AI analysis

Scraping the HTML misses what the page actually looks like. A CTA might exist in the DOM but sit below three screens of content. CSS transforms and lazy-loaded images change the rendered result. Responsive breakpoints shift the layout entirely. Vision models score visual hierarchy from pixels, not markup. That's what an AI conversion audit cares about. Lighthouse gives you performance metrics. Axe-core finds missing alt text. Neither one tells you "the CTA is visually weak and there's no social proof above the fold."

What vision models can actually score from a screenshot

I've tested this across GPT-4o and Claude with a few hundred landing page screenshots. Some things work reliably, some don't.

CTA identification and prominence scoring works well. The model spots buttons, scores their visual weight, and cites evidence ("primary CTA uses the same color as the navigation links, reducing contrast"). Visual hierarchy analysis is solid too. It can map primary, secondary, and tertiary content zones and flag when they compete for attention.

Trust signal detection is high-reliability. Testimonials, security badges, partner logos, customer counts. The model finds them and notes their placement. Copy clarity is medium-high: it evaluates headline strength and value propositions, but sometimes overvalues cleverness over clarity.

Where it gets shaky: exact pixel measurements (don't trust them), precise color values (use a proper tool), and predicting actual user behavior. The model tells you what the page looks like. It doesn't tell you what users do. That's still Hotjar's job.

Baymard Institute tested GPT-4 on UX audits and found an 80% error rate with only 14-26% of real issues discovered. That sounds bad, and it is if you're using it as a replacement for expert review. It's good if you use it as a hypothesis generator. A fast first pass that flags areas for a human to investigate. That's how I'd frame it.

Capture a landing page screenshot for AI analysis

The full-page parameter captures the entire scrollable document. For AI analysis, you usually want the complete page, not just the viewport. Add cookie blocking and ad blocking to remove noise that would confuse the model.

curl "https://api.screenshotrun.com/v1/screenshots/capture?\
url=https://competitor.com/pricing\
&full_page=true\
&block_ads=true\
&block_cookies=true\
&block_chats=true\
&format=png\
&width=1280\
&response_type=json" \
  -H "Authorization: Bearer YOUR_API_KEY"

PNG format gives the model lossless input. The 1280px width matches the most common desktop viewport across our users. If you need mobile analysis too, make a second call with device=mobile or width=375.

Score a landing page with GPT-4o

Once you have the screenshot URL from the API response, pass it to your vision model. This Python example uses OpenAI's GPT-4o:

import requests
import openai

# Step 1: Capture the page
screenshot = requests.get(
    "https://api.screenshotrun.com/v1/screenshots/capture",
    params={
        "url": "https://competitor.com/pricing",
        "full_page": "true",
        "block_ads": "true",
        "block_cookies": "true",
        "format": "png",
        "response_type": "json",
    },
    headers={"Authorization": "Bearer SR_API_KEY"},
).json()

image_url = screenshot["data"]["screenshot_url"]

# Step 2: Analyze with GPT-4o
analysis = openai.chat.completions.create(
    model="gpt-4o",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": (
                "Analyze this landing page screenshot. Score 1-5 on: "
                "CTA prominence, visual hierarchy, trust signals, "
                "copy clarity, mobile readiness. "
                "Cite visible evidence for each score. "
                "Give one testable improvement. Return JSON."
            )},
            {"type": "image_url", "image_url": {"url": image_url}},
        ],
    }],
)

print(analysis.choices[0].message.content)

Two API calls, maybe 4 seconds total. The prompt matters more than the model choice. A vague "analyze this page" gives you vague results. Structured scoring criteria with "cite visible evidence" produces useful output. I've found that asking for JSON back makes the results easier to compare across pages. Claude handles longer page screenshots well because of its larger context window, if that matters for your pages.

Analyze specific page sections with the selector parameter

A full-page screenshot of a long landing page can be 5,000+ pixels tall. That's a lot of visual information for the model to process, and it dilutes the analysis. If you care about the hero section specifically, capture just that.

The selector parameter lets you crop to a specific element by CSS selector. Pass selector=.hero and you get just the hero section. Pass selector=footer and you get the footer. Run separate analyses on each section with targeted prompts.

sections = {
    "hero": ".hero, [class*='hero'], header .banner",
    "pricing": "[class*='pricing'], [id*='pricing']",
    "testimonials": "[class*='testimonial'], [class*='review']",
    "cta_area": "[class*='cta'], .signup-form",
}

for label, sel in sections.items():
    resp = requests.get(
        "https://api.screenshotrun.com/v1/screenshots/capture",
        params={
            "url": "https://competitor.com",
            "selector": sel,
            "block_ads": "true",
            "format": "png",
            "response_type": "json",
        },
        headers={"Authorization": "Bearer SR_API_KEY"},
    )
    if resp.ok:
        # Send each section screenshot to AI with section-specific prompt
        analyze_section(label, resp.json()["data"]["screenshot_url"])

Some selectors won't match on every page. The API returns an error when a selector is missing, so your script should skip those and move on. Across 20+ competitor pages, common patterns like .hero and footer match often enough to produce a useful analysis set.

Automate landing page audits overnight

One page at a time is a demo. An automated landing page audit runs this against a list of competitors on a schedule. Capture 30 competitor pricing pages, analyze each, aggregate the scores into a spreadsheet. Run it monthly and track how competitors evolve their pages.

import requests
import openai
import json

SR_KEY = "YOUR_SCREENSHOTRUN_KEY"
URLS = open("competitor-urls.txt").read().splitlines()

PROMPT = (
    "Score this landing page 1-5 on: CTA prominence, visual hierarchy, "
    "trust signals, copy clarity. Cite evidence. Return JSON with keys: "
    "cta_score, hierarchy_score, trust_score, copy_score, evidence, recommendation."
)

results = []
for url in URLS:
    # Capture
    shot = requests.get(
        "https://api.screenshotrun.com/v1/screenshots/capture",
        params={"url": url, "full_page": "true", "block_ads": "true",
                "block_cookies": "true", "format": "png", "response_type": "json"},
        headers={"Authorization": f"Bearer {SR_KEY}"},
    ).json()

    # Analyze
    ai = openai.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": [
            {"type": "text", "text": PROMPT},
            {"type": "image_url", "image_url": {"url": shot["data"]["screenshot_url"]}},
        ]}],
    )
    results.append({"url": url, "analysis": ai.choices[0].message.content})

with open("competitor-audit.json", "w") as f:
    json.dump(results, f, indent=2)
print(f"Analyzed {len(results)} pages")

30 screenshots cost about $0.30 on the Starter plan. 30 GPT-4o vision calls cost roughly $0.15. Under fifty cents for a competitive analysis that would take a consultant days. Schedule it as a monthly GitHub Actions workflow or a cron job. The Python integration guide has the full error handling setup.

More ways to use AI website audit screenshots

Accessibility is one that surprised me. Capture a page at multiple viewport sizes and ask the model to check for visual issues: text over busy backgrounds, small touch targets, low-contrast elements, missing visible focus states. Automated scanners like Axe catch code-level WCAG violations. Vision models catch visual ones that scanners miss, like a button that meets contrast requirements in CSS but gets overlaid by a background image at certain breakpoints.

A/B test analysis pairs well with this approach too. Capture both variants, feed both screenshots to the model in a single prompt: "Compare these two page variants. Which has stronger visual hierarchy? What specific visual differences might explain a conversion difference?" Good for adding qualitative context to quantitative test data from VWO or Optimizely.

Multi-locale checks work by using the geolocation parameter to capture the same page from different countries. German and Japanese translations tend to break narrow button layouts. Ask the model: "Which locale has layout breakage? Any truncated CTAs?" You'll catch overflow issues that manual QA misses across 12 locales.

Brand consistency is the fourth. Capture 20 product pages, feed all to the model with your brand guidelines as context, get a report on which pages deviate. The model spots where pages deviate from your color palette or button styles faster than any human could.

What this approach won't catch

AI vision analysis is a fast first pass, not a replacement for proper UX research. It can't tell you what real users actually do on the page. Scroll depth, click patterns, form abandonment — that's analytics, not vision. It doesn't know your audience. And it makes mistakes. The Baymard study found that GPT-4 flagged design patterns as "problems" that were actually intentional and well-tested.

Use it for hypothesis generation. "The AI thinks the CTA is too low and the trust signals are weak" is a starting point for investigation, not a conclusion. Run the actual A/B test before you redesign anything based on AI feedback alone.

The other limitation is model consistency. Ask the same model the same question twice and you might get different scores. For tracking changes over time, pin the model version and use structured JSON output with fixed scoring criteria. That helps, but it doesn't eliminate variance entirely.

Screenshot API for AI vision: the capture layer

The AI website analysis API call is the capture step. You bring the vision model. That separation is intentional: you're not locked into one provider. GPT-4o for general analysis, Claude for longer pages. Switch models when better ones come out. The screenshot stays the same.

Start with your own landing page. Capture it at 1280px, feed it to whichever vision model you have access to, and ask for a conversion score. If the output is useful, scale it to competitors. You get 200 screenshots per month on the free plan. Check pricing when you need more. For AI agents that browse autonomously rather than analyze on demand, see the screenshots for AI agents use case. For building training datasets from screenshots, see AI training datasets.

FAQ#