Brand Monitoring Screenshot API

Brand teams that manage partner networks, reseller programs, or franchise locations need to see how their brand actually looks on other people's websites. Not what the partner promised in a slide deck, but what a customer in Berlin or São Paulo sees when they land on the page. ScreenshotRun turns that check into an API call: pass a URL, get back a screenshot with consent banners, ads, and chat widgets already stripped out. Add certified=true and every capture comes back with a SHA-256 hash and RFC 3161 timestamp, turning it into evidence you can hand to your legal team.

Manual brand audits work when you have ten partners. They stop working somewhere around fifty. By the time you're checking two hundred reseller sites across three countries, you're spending a full workday just opening tabs and saving files. The API reduces that to a script you schedule once.

Two hundred partner sites, one cron job

Most brand monitoring starts with a spreadsheet of URLs: authorized resellers, affiliate landing pages, franchise microsites. This Python script reads each URL, captures it with consent overlays and support bubbles stripped out, and saves a dated screenshot to disk:

import httpx, os, datetime

API_KEY = os.environ["SCREENSHOTRUN_KEY"]
BASE = "https://api.screenshotrun.com/v1/screenshots/capture"
today = datetime.date.today().isoformat()

partners = [
    "https://partner-one.com/our-products",
    "https://reseller-east.com/brand-name",
    "https://franchise-chicago.com",
    "https://affiliate-uk.co.uk/landing",
]

for url in partners:
    slug = url.split("//")[1].replace("/", "--").replace(".", "-")
    resp = httpx.get(BASE, params={
        "url": url,
        "format": "webp",
        "full_page": "true",
        "block_cookies": "true",
        "block_chats": "true",
        "block_ads": "true",
        "extract_metadata": "true",
        "response_type": "image",
    }, headers={"Authorization": f"Bearer {API_KEY}"}, timeout=60)

    path = f"brand-audit/{today}/{slug}.webp"
    os.makedirs(os.path.dirname(path), exist_ok=True)
    with open(path, "wb") as f:
        f.write(resp.content)
    print(f"{slug} ({len(resp.content) // 1024} KB)")

Four URLs, four clean full-page WebP files organized in a date folder. Swap those four for two hundred and the run still finishes in minutes because our servers handle the captures concurrently. Schedule it as a weekly cron job or a GitHub Action and the reference library builds itself.

extract_metadata=true returns the page title and description alongside the image. That's useful for checking whether partners are using your brand name correctly in their SEO tags (or dropping it entirely).

Isolate the brand zone with a CSS selector

Full-page captures are good for broad audits. But when you're checking whether a reseller uses the right logo or the right color in their header, you don't need 8,000 pixels of page content. The selector parameter crops the screenshot to a specific element.

curl -G "https://api.screenshotrun.com/v1/screenshots/capture" \
  -H "Authorization: Bearer $SCREENSHOTRUN_KEY" \
  --data-urlencode "url=https://reseller-example.com" \
  --data-urlencode "selector=header" \
  --data-urlencode "format=png" \
  --data-urlencode "retina=true" \
  --data-urlencode "block_cookies=true" \
  --data-urlencode "response_type=image" \
  -o reseller-header.png

You get just the header. Logo, navigation, brand colors, nothing else. Run this across your entire partner list and you've got a visual comparison board of every reseller's header in one folder. Spotting the one using your old logo (or a competitor's shade of blue) takes seconds instead of hours.

retina=true doubles pixel density, which matters when you're comparing fine details like logo resolution or font weight. Keep in mind that retina captures are 4x the file size (both width and height double), so stick with standard resolution for routine monitoring and use retina for deep-dive audits.

Screenshots that hold up in court

A regular browser screenshot is just a PNG file. Anyone can edit it, and there's no independent proof of when it was taken or what the page looked like at that moment. If you're building a trademark infringement case or filing a DMCA takedown, you need something stronger.

The certified screenshot parameter adds a cryptographic layer. Each capture comes back with a SHA-256 hash of the image content and an RFC 3161 certified timestamp from an independent timestamping authority. Under US federal rules (FRE 902(13)/(14)), this combination can self-authenticate as evidence without a live witness. The EU equivalent under eIDAS works similarly.

For trademark enforcement, capture the infringing page daily until it's taken down. Date-stamped folders create a timeline that shows ongoing infringement, not a one-time snapshot. Pair with full_page=true to document the entire page and extract_metadata=true to capture the page title and description (useful if the infringer is SEO-hijacking your brand name).

Enterprise brand protection platforms like BrandShield and Red Points charge five figures annually for forensic capture workflows. The API gives you the same capture primitives for a few dollars a month. You still need a lawyer, but you don't need a $30K platform to collect the evidence.

Check how your brand looks from Tokyo

Partners and resellers often serve different content by geography. A US-based franchise page might show correct branding while the same franchisee's UK page uses an outdated logo or unauthorized pricing. The geolocation parameter captures the page as seen from a specific country:

const API_KEY = process.env.SCREENSHOTRUN_KEY;
const regions = ['us', 'gb', 'de', 'jp', 'br'];
const partnerUrl = 'https://reseller-global.com/products';

for (const geo of regions) {
  const params = new URLSearchParams({
    url: partnerUrl,
    format: 'webp',
    geolocation: geo,
    full_page: 'true',
    block_cookies: 'true',
    stealth: 'true',
    response_type: 'image',
  });

  const res = await fetch(
    `https://api.screenshotrun.com/v1/screenshots/capture?${params}`,
    { headers: { Authorization: `Bearer ${API_KEY}` } }
  );

  if (res.ok) {
    const fs = await import('fs');
    fs.writeFileSync(`brand-audit/geo/${geo}.webp`,
      Buffer.from(await res.arrayBuffer()));
    console.log(`${geo}: ${Math.round(
      res.headers.get('content-length') / 1024)} KB`);
  }
}

Five captures of the same URL, each from a different country. Drop them side by side and you can see whether the Japanese version uses translated brand messaging that deviates from guidelines, or whether the Brazilian reseller page shows pricing you didn't authorize.

stealth=true is included here because some reseller sites detect headless browsers and serve different content (or block the request entirely). Stealth mode makes Chrome look like a regular desktop browser, which gets you the same page a real customer would see.

When a partner page changes overnight

Scheduled captures show you the current state. But brand violations often appear between audits: a partner swaps your logo for a competitor's, or rewrites your product description with unauthorized claims. To catch these quickly, you need change detection.

The approach: capture weekly, then compare each screenshot to the previous week's version using pixel diffing. If the difference crosses a threshold, flag it for review. SSIM (structural similarity) works well here because it ignores minor rendering differences (ad rotation, timestamp changes) while catching layout and brand element changes. Our website change monitoring page covers the SSIM implementation in detail.

For real-time alerts, use the webhook parameter. Fire off capture requests with webhook_url pointing at your server. When each screenshot is ready, your endpoint receives the image, runs it through your comparison pipeline, and sends a Slack alert if something looks off. The whole chain runs without polling or blocking.

Capture cadence depends on risk. Daily works for MAP pricing compliance (resellers changing prices overnight is common). Weekly handles most brand guideline checks. For high-value trademark monitoring during active infringement, daily captures with certified=true build a stronger evidence package.

Parameters for brand monitoring workflows

Full parameter reference in the API docs.

Franchise compliance at API prices

Dedicated franchise compliance platforms charge $30-50 per location per month. A 200-location franchise pays $6,000-10,000 monthly just for compliance monitoring. The screenshot API approach costs less than a single location's monthly fee.

On the Pro plan ($29/month, 15,000 captures), a weekly audit of 200 franchise sites across desktop and mobile is 1,600 captures per month. That's roughly 11% of the plan's allocation, leaving room for retina deep-dives, geo checks, and trademark monitoring alongside it.

The tradeoff is clear: compliance platforms give you a dashboard, alerts, and workflow management out of the box. The API gives you raw captures that you wire into your own tooling. If your brand team already uses Notion, Airtable, or an internal portal for compliance tracking, feeding screenshots into that existing system is cheaper and more flexible than adopting another SaaS platform.

Combine with an AI vision model (GPT-4o or Claude) and you can automate the review step too. Feed each franchise screenshot to the model with your brand guidelines as context: "Does this page use the approved logo? Is the header color within #2D5BFF ± 10%? Does the footer include the required legal disclaimer?" The model returns a pass/fail score per location, cutting manual review from hours to minutes.

What this setup won't catch

The API captures what a browser renders at a specific URL. A few things sit outside that scope.

Social media brand monitoring (Instagram posts, TikTok bios, YouTube thumbnails) requires platform-specific approaches. Public social profiles can be captured, but most brand abuse on social platforms happens in posts, stories, and ads that are gated behind authentication or app-only interfaces. Tools like Brand24 and Mention cover the text side of social monitoring. For visual social monitoring (detecting your logo in images across social media), VISUA and Talkwalker have AI-powered logo recognition that works differently from screenshot capture.

Login-gated partner portals won't render without session cookies. The API supports a cookies parameter for sessions you control, but managing hundreds of partner login credentials creates its own operational burden. Most brand monitoring focuses on public-facing pages, where authorization isn't an issue.

Some reseller sites aggressively block headless browsers. Stealth mode handles most of these (roughly 95% in our testing), but it's not bulletproof. If a specific site consistently returns different content to the API than to your browser, it might need a different monitoring approach.

If your goal is tracking what competitors are doing on their own sites (pricing changes, feature launches, redesigns), that's a different workflow. Our competitor monitoring page covers that angle. Brand monitoring is the reverse: watching how your brand appears on other people's sites. And this probably goes without saying, but the API captures visual state. It doesn't parse the page content or detect semantic brand violations. If a partner writes "best in class" instead of your approved tagline "built for professionals," a screenshot shows both versions side by side, but it won't flag the difference automatically. That's where the AI vision model layer comes in.

Why ScreenshotRun for brand monitoring

Most brand monitoring tools (Brand24, Mention, Talkwalker) track where your brand gets mentioned. They don't show you what the page actually looks like. Dedicated compliance platforms (PerformLine, BrandShield) do the visual part, but they cost $30K+ a year and lock you into their workflow. ScreenshotRun sits in the gap: you get the raw captures, certified timestamps for legal evidence, geo-targeting for multi-market checks, and stealth mode for sites that block bots. Wire it into whatever stack your team already uses.

The free plan includes 200 captures per month with every parameter available, no feature gating. That's enough to monitor 50 partner sites weekly and see whether the setup works for your brand team before scaling up. For recurring captures, see scheduled screenshots. For automation without code, connect through Zapier, Make, or n8n.