Automate Marketing Screenshots via API

Marketing screenshot automation turns URLs into images on a schedule, without anyone opening a browser. The ScreenshotRun API handles the capture side: marketing teams wire it into their daily operations to archive landing pages, capture competitor sites, collect social proof, and build reports with actual visuals instead of links that expire.

This page covers the marketing-specific workflows. If you're looking for competitor website tracking in depth, that's competitor monitoring. For email campaign archival, see email marketing screenshots. For generating OG images programmatically, OG image generator has you covered. What we're talking about here is the broader picture: how a screenshot API for marketing teams fits into daily operations.

What marketing screenshot automation covers

Most teams adopting marketing screenshot automation start with one of these workflows and expand from there.

Landing page archives come first for most people. Every campaign gets a landing page, sometimes three or four variants, and once the campaign ends the page changes or disappears. An API call with full_page=true saves the entire page as a single tall PNG or PDF before that happens.

Competitor tracking is the other big one. Pricing pages, feature announcements, promotional banners, ad landing pages. The competitor monitoring page covers the batch workflows for tracking dozens of URLs weekly.

Social proof is harder to keep than people think. Tweets, LinkedIn posts, G2 reviews, Reddit comments that mention your brand. Social content disappears: accounts go private, posts get deleted, threads get archived. A screenshot captured when the mention is fresh is the only reliable record.

Agencies paste dashboard screenshots into decks every week. The API automates the "log into GA4, scroll, screenshot, crop, paste" loop for every client in the roster. And growth teams run experiments, pick a winner, clean up the variant code. Two quarters later, someone asks what Variant B looked like. Nobody knows. Automated captures at experiment launch fix that permanently.

Automated landing page screenshots and A/B test variants

Landing pages are temporary by design. A Black Friday promo runs for 10 days, and once the campaign ends, the page gets redesigned or taken down before anyone thinks to archive it. The before-and-after visual record matters for post-campaign analysis (and for showing the CMO what the old page looked like), but it only exists if someone captured it.

Set up a script that runs after every deploy or on a weekly schedule. The simplest version is one curl call per page:

curl "https://api.screenshotrun.com/v1/screenshots/capture" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -G \
  --data-urlencode "url=https://yoursite.com/promo/black-friday-2026" \
  --data-urlencode "full_page=true" \
  --data-urlencode "block_cookies=true" \
  --data-urlencode "block_ads=true" \
  --data-urlencode "format=png" \
  -o black-friday-2026.png

block_cookies=true strips consent banners that would cover the hero section. block_ads=true removes retargeting pixels and third-party ad scripts that occasionally inject overlays on your own pages (happens more often than you'd think, especially with tag manager bloat). See block cookies and ad blocking for what these actually remove under the hood.

For A/B test variants, capture both URLs at experiment launch. Label them clearly: exp-47-control.png, exp-47-variant-b.png. The conversion data lives in your experimentation platform. The visual record lives in your archive. Six months from now, when someone asks "what did we change on that pricing page test?" you'll have the answer in two PNGs instead of a shrug.

From what I've seen working with growth teams, the experiments worth documenting aren't always the big redesigns. Sometimes a button color change or a single headline swap moved the needle, and without a visual diff those learnings evaporate. Whether you need to screenshot competitor ads automatically or track weekly pricing changes, the batch approach handles both.

Agency client reporting

Here's the weekly ritual at most agencies with 10+ clients: someone opens Chrome, logs into GA4 for Client A, scrolls to the traffic chart, takes a screenshot, opens Meta Ads Manager, takes another screenshot, opens the LinkedIn campaign dashboard, takes a third. Pastes all three into a Google Slides deck. Repeats for Client B through Client O. Across 10+ clients, that adds up to a full workday or more per week for the team.

A screenshot API for marketing reporting compresses that into a Python script that runs on Monday morning while the team is in standup:

import requests
import os

API_KEY = "YOUR_API_KEY"
BASE = "https://api.screenshotrun.com/v1/screenshots/capture"

# Note: authenticated dashboards need cookies
# See /use-cases/screenshot-behind-login
clients = {
    "acme-corp": [
        "https://analytics.google.com/analytics/web/#/.../report/...",
        "https://adsmanager.facebook.com/adsmanager/reporting/...",
    ],
    "globex-inc": [
        "https://analytics.google.com/analytics/web/#/.../report/...",
        "https://ads.linkedin.com/reporting/...",
    ],
}

for client, urls in clients.items():
    os.makedirs(f"reports/{client}", exist_ok=True)
    for i, url in enumerate(urls):
        resp = requests.get(BASE, headers={"Authorization": f"Bearer {API_KEY}"},
            params={
                "url": url,
                "full_page": True,
                "delay": 3000,
                "width": 1280,
                "format": "png",
                "block_cookies": True,
            }, timeout=60)
        if resp.status_code == 200:
            with open(f"reports/{client}/dashboard-{i+1}.png", "wb") as f:
                f.write(resp.content)

Here's the catch: that delay=3000 is doing the heavy lifting. Analytics dashboards are JavaScript-heavy apps that load charts asynchronously. Without a delay, you capture a page full of loading spinners instead of actual data. Three seconds handles most cases. For heavy dashboards (Looker, some Power BI embeds), bump it to 5000ms. How do you know if it's enough? Run the capture once and check the output.

I spent a week helping a 12-person agency automate their Monday reporting. The delay parameter was the sticking point -- they kept getting blank charts until we bumped it to 5000ms for their Looker embeds. If you're capturing dashboards that require login, you'll need to extract session cookies from your browser, but the tokens expire fast, so most teams automate that refresh with a headless login step. The screenshot behind login page covers the cookie mechanics.

Want PDF reports instead of PNGs? Swap format=pdf. Each dashboard becomes a one-page PDF you can stitch together with PyPDF2 or attach directly to a client email. The no-code workflow section below covers how to schedule this without writing code.

Automated social proof screenshots

A positive tweet about your product has a shelf life. The author might delete it, go private, or X (formerly Twitter) might change their embed format again. A G2 review stays up longer, but the formatting changes, and the star count shifts as new reviews come in. If you want a visual record of that 5-star review from your biggest customer, capture it now.

Element screenshots work well here. Instead of capturing the entire page (with all the surrounding navigation, ads, and unrelated content), pass a CSS selector parameter to grab just the review card or tweet container:

curl "https://api.screenshotrun.com/v1/screenshots/capture" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -G \
  --data-urlencode "url=https://www.g2.com/products/your-product/reviews" \
  --data-urlencode "selector=.paper--review:first-child" \
  --data-urlencode "delay=2000" \
  --data-urlencode "block_cookies=true" \
  --data-urlencode "retina=true" \
  --data-urlencode "format=png" \
  -o top-review.png

retina=true captures at 2x resolution, which makes the screenshot look crisp in slide decks and social media posts. Without it, text looks blurry when you scale the image up. At 2x, a 400px-wide review card produces an 800px image that looks sharp on any screen. (Retina screenshots are 4x the file size, not 2x, because both width and height double. Budget your storage accordingly.)

We had a customer lose a glowing Product Hunt comment thread because the poster deleted their account two days later. That's what pushed us to add the element screenshot examples to our onboarding docs. For tracking brand mentions across platforms, teams typically maintain a spreadsheet of URLs (or pull them from a social listening tool like Mention or Brandwatch) and batch-capture them daily. The Google Sheets integration handles the spreadsheet-to-API pipeline if you don't want to write code.

Brand consistency across regions and devices

A franchise with localized landing pages in 8 countries needs to verify that the logo, color palette, CTA copy, and layout match brand guidelines everywhere. That's a manual nightmare. A SaaS company launching in EMEA wants to see what the signup page looks like from Frankfurt versus what the US team sees from San Francisco.

Two parameters handle this: geolocation for region-specific renders, and device (or width/height) for viewport variations. Combine them for a matrix of captures:

import requests
import os

API_KEY = "YOUR_API_KEY"
BASE = "https://api.screenshotrun.com/v1/screenshots/capture"

url = "https://yoursite.com/signup"
regions = [
    {"label": "us", "geo": "us"},
    {"label": "de", "geo": "de"},
    {"label": "jp", "geo": "jp"},
    {"label": "br", "geo": "br"},
]
devices = [
    {"label": "desktop", "width": 1280, "height": 800},
    {"label": "mobile", "width": 375, "height": 812, "device": "mobile"},
]

os.makedirs("brand-audit", exist_ok=True)
for region in regions:
    for dev in devices:
        params = {
            "url": url,
            "full_page": True,
            "geolocation": region["geo"],
            "width": dev["width"],
            "height": dev["height"],
            "block_cookies": True,
            "format": "png",
        }
        if "device" in dev:
            params["device"] = dev["device"]
        resp = requests.get(BASE, headers={"Authorization": f"Bearer {API_KEY}"},
            params=params, timeout=60)
        if resp.status_code == 200:
            fname = f"brand-audit/{region['label']}-{dev['label']}.png"
            with open(fname, "wb") as f:
                f.write(resp.content)
            print(f"Captured: {fname}")

That script produces 8 screenshots (4 regions x 2 devices) in about 30 seconds. How long does the manual version take? VPN switching, browser resizing, individual screenshots. That takes 20-30 minutes, and nobody does it consistently. The geo screenshots page goes deeper into the geolocation workflows.

Some teams pipe these captures into visual comparison tools or even GPT-4 Vision to flag deviations automatically. Whether that's accurate enough to replace a human reviewer is an open question -- we're still testing it. The AI web analysis page covers that integration. For dedicated responsive testing workflows, see responsive design preview.

No-code workflows with Zapier, n8n, and Make

Not every marketing team has a developer who'll write Python scripts. The API works with Zapier, n8n, and Make.com for teams that prefer visual workflow builders.

A few recipes that work well:

• A competitor page changes (detected via Visualping or a custom webhook), so the API captures it and posts the screenshot to Slack. Your team sees the visual diff without opening a browser.
• New row in Google Sheet (URL list) triggers the screenshot API, which saves the image to a Google Drive folder. Marketing ops adds a URL, the screenshot appears in the shared drive automatically.
• Weekly schedule trigger fires, batch-captures 20 competitor URLs, compiles them into a PDF report, and emails it to stakeholders. Runs every Monday. Nobody touches it.

The webhook parameter is useful here: instead of waiting for the screenshot to render synchronously, the API accepts the request and POSTs the finished image to your endpoint when it's ready. For bulk capture workflows with 50+ URLs, async delivery via webhook keeps your automation pipeline from blocking.

Which parameters matter most for marketing?

The CSS/JS injection page covers the injection parameters in detail.

Limitations worth knowing

A few things that don't work perfectly in marketing screenshot workflows:

• GA4, Meta Ads Manager, and most analytics platforms require login. The API supports cookies and headers parameters for session tokens, but you'll need to extract and refresh those tokens. As far as I can tell, most analytics platforms cycle their session tokens every 24-48 hours, so plan your refresh accordingly. See screenshot behind login for the setup.
• If a landing page shows different content based on visitor behavior or account data, the API captures the default (non-personalized) version. You can override some of this with cookies or URL parameters, but pixel-for-pixel personalized captures require the right session state.
• Social media feeds and some blog index pages don't have a natural bottom. full_page=true captures what's loaded at capture time, not the entire infinite feed. For these, set a specific height or use scroll_to to control how far down the page the renderer scrolls.
• The thing is, some sites detect headless browsers and serve different content (or block access entirely). The stealth mode parameter helps, but it's an arms race. Does your target site block headless browsers? Run one capture and check.

Marketing screenshot automation is a one-time setup investment. Build the script or Zapier flow once, point it at your URL list, and let it run. Screenshots don't forget. People do. Check the pricing page for per-screenshot costs at different volumes.

FAQ#