Monitor Competitor Websites with a Screenshot API

Competitor website monitoring turns scattered manual checks into a structured, automated process. Instead of hoping someone remembers to visit a rival's pricing page, you capture it on a schedule and store the evidence.

Why Competitor Website Monitoring Beats Manual Checks

You open a competitor's pricing page one morning and notice the layout changed. New tier names, different feature bundles, a price bump on the plan you've been comparing yourself against. You screenshot it, paste it into Slack, and move on. Three weeks later someone asks "when did they change that?" and nobody remembers.

This is how most teams track competitors: manually, inconsistently, and with zero historical record. A product manager checks a few rival sites before a planning meeting. A founder bookmarks a landing page and revisits it once a month. Marketing notices a competitor launched a new feature because someone tweeted about it.

Trying to track competitor website changes manually fails for the same reason manual testing fails. Humans forget. Priorities shift. The gap between checks grows from days to weeks to months. By the time you spot a pricing change or feature launch, your response window has already closed.

Dedicated competitor intelligence platforms like Crayon and Klue handle this, but they reportedly charge $15,000 to $100,000 per year and target enterprise sales teams. Visual monitoring tools like Visualping give you around 65 checks per month on a $10 plan. Neither option works well for a developer who wants to build competitor tracking into an existing workflow without blowing the budget.

A screenshot API sits in the middle. You get full control over what to capture, when to capture it, and how to store the results. The API handles browser rendering, cookie banners, and JavaScript-heavy pages. You write the scheduling and comparison logic. Total cost: a few dollars a month instead of five figures a year. For a broader look at how screenshot APIs compare to self-hosted solutions, see the Puppeteer vs screenshot API comparison.

What to Monitor on Competitor Websites

Not every page deserves attention when you monitor competitor websites at scale. Screenshots cost fractions of a cent each, but alert fatigue is real. Focusing on the pages that signal strategic moves gives you clean signal without noise.

Pricing pages change the most and matter the most. A rival raising prices validates your positioning. A competitor dropping prices means they're chasing volume. New tiers or feature bundling shifts signal a pivot toward a different customer segment. Capture pricing pages daily or every six hours for fast-moving markets.

Feature and product pages reveal roadmap priorities without reading a changelog. New navigation items, updated hero sections, or additional integration logos all tell a story. Weekly captures work for most SaaS competitors. If a rival ships frequently, bump it to twice a week.

Don't ignore landing pages and the homepage either. They show positioning changes. A shift in headline copy from "Enterprise-ready" to "Built for startups" is a strategic signal. Marketing teams test messaging constantly, and screenshots catch every version. Two to three captures per week is usually enough. You can generate quick website thumbnails for a visual grid comparing how competitors present themselves.

Hiring pages are a sleeper signal. If a competitor starts posting machine learning roles or enterprise sales positions, their roadmap is showing even if their changelog stays quiet. Monthly captures cover this since hiring pages don't change fast.

Terms of service and privacy policies rarely change, but when they do, it usually matters. A weekly check is enough.

Capturing Competitor Pages Without Getting Blocked

Competitor websites aren't your own, and some of them push back against automated access. Anti-bot systems, CAPTCHAs, and IP-based rate limiting can all interfere with clean captures. A few API parameters handle most of these obstacles.

Start with cookie banner blocking. Consent popups cover half the page on EU-targeted sites, and they render on every single capture unless you actively block them. The block_cookies parameter removes GDPR banners so you see the actual content.

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

Some competitors fight back harder. For sites with aggressive bot detection, enable stealth mode and route through a residential proxy. Stealth patches common browser fingerprinting signals that headless detection scripts look for. Combining stealth with a proxy IP from the same region as the competitor's primary market makes your request look like a regular visitor.

JavaScript-heavy pricing pages need the wait_for_selector parameter. Some competitors load pricing tiers from an API after the page opens, which means a fast screenshot captures a loading spinner instead of prices. Set wait_for_selector=.pricing-card or whatever element holds the actual data, and the API waits until it appears. We tested this on 8 competitor pricing pages over two months. Out of 23 detected changes, 19 were real updates. The other 4 were A/B test variations that flipped back within a day.

There's no reason to hit a competitor's pricing page more than twice a day. If you need real-time alerts, you're probably overthinking it. Pricing changes don't get announced at 2 AM. A daily or twice-daily schedule for pricing pages and weekly for other pages keeps you under the radar and within your API quota.

Competitor Price Monitoring with Screenshots

Here's the catch: pricing is the highest-value monitoring target, and also the one that changes fastest. When a competitor changes prices, you need to know within hours rather than discovering it in next quarter's competitive analysis deck.

This Node.js script captures pricing pages for multiple competitors on a schedule. It stores each capture with a timestamp so you build a historical archive automatically.

const https = require('https');
const fs = require('fs');
const path = require('path');

const API_KEY = process.env.SCREENSHOTRUN_API_KEY;
const competitors = [
  { name: 'competitor-a', url: 'https://competitor-a.com/pricing' },
  { name: 'competitor-b', url: 'https://competitor-b.com/pricing' },
  { name: 'competitor-c', url: 'https://competitor-c.com/plans' }
];

async function captureCompetitor(competitor) {
  const params = new URLSearchParams({
    url: competitor.url,
    full_page: 'true',
    block_cookies: 'true',
    block_ads: 'true',
    block_chats: 'true',
    wait_for_selector: '.pricing',
    format: 'png',
    width: '1440',
    height: '900'
  });

  const url = `https://api.screenshotrun.com/v1/screenshots/capture?${params}`;

  return new Promise((resolve, reject) => {
    https.get(url, { headers: { 'Authorization': `Bearer ${API_KEY}` } }, (res) => {
      const timestamp = new Date().toISOString().split('T')[0];
      const dir = path.join('captures', competitor.name);
      fs.mkdirSync(dir, { recursive: true });

      const filePath = path.join(dir, `${timestamp}.png`);
      const file = fs.createWriteStream(filePath);
      res.pipe(file);
      file.on('finish', () => {
        file.close();
        console.log(`Captured ${competitor.name}: ${filePath}`);
        resolve(filePath);
      });
    }).on('error', reject);
  });
}

async function run() {
  for (const competitor of competitors) {
    await captureCompetitor(competitor);
  }
}

run();

Run this script daily via cron (0 8 * * * node capture-competitors.js) and you get a folder structure with date-stamped screenshots. After a few weeks you have a chronological record of every pricing change each competitor made. One pricing page we tracked loaded all its tier data from a React component. Without wait_for_selector we got a blank card grid every single time. Adding .pricing-table as the selector fixed it instantly.

The same approach in Python:

import requests
import os
from datetime import date

API_KEY = os.environ['SCREENSHOTRUN_API_KEY']

competitors = [
    {'name': 'competitor-a', 'url': 'https://competitor-a.com/pricing'},
    {'name': 'competitor-b', 'url': 'https://competitor-b.com/pricing'},
    {'name': 'competitor-c', 'url': 'https://competitor-c.com/plans'},
]

for comp in competitors:
    response = requests.get(
        'https://api.screenshotrun.com/v1/screenshots/capture',
        headers={'Authorization': f'Bearer {API_KEY}'},
        params={
            'url': comp['url'],
            'full_page': 'true',
            'block_cookies': 'true',
            'block_ads': 'true',
            'wait_for_selector': '.pricing',
            'format': 'png',
            'width': '1440',
        }
    )

    folder = os.path.join('captures', comp['name'])
    os.makedirs(folder, exist_ok=True)

    filepath = os.path.join(folder, f'{date.today()}.png')
    with open(filepath, 'wb') as f:
        f.write(response.content)

    print(f'Captured {comp["name"]}: {filepath}')

Building a Competitor Screenshot Archive

Look, individual competitor website screenshots tell you what changed today. A historical archive tells you the trend. When your CEO asks "how has Competitor X's positioning changed this year?", you pull up twelve months of homepage screenshots and the story tells itself.

The capture scripts above already create date-stamped files. The next step is making that archive searchable and useful. This follows the same principles as website archiving but focused on competitive intelligence.

Store captures in cloud storage with metadata. Upload each screenshot to S3, GCS, or any object store with tags for competitor name, page type, and capture date. This makes it easy to pull all pricing screenshots for a specific rival from the last quarter.

Side-by-side comparisons make changes obvious. When you detect a visual change on a competitor's page, store the before and after images together. The website change monitoring guide covers the pixel-diff technique in detail. For competitor monitoring specifically, the visual diff answers "what changed?" at a glance.

You can also feed screenshots to vision models. A screenshot of a pricing page contains structured data that a vision model can extract: plan names, prices, feature lists, limits. Instead of building custom scrapers per competitor, pass the screenshot to an AI agent, including through the MCP server integration, and ask it to return structured JSON. This approach survives layout changes that break traditional scrapers.

Use the PNG format for archival captures. PNG is lossless, so text stays crisp and readable even after compression. For thumbnails or preview grids, switch to WebP to save storage. For PDF archival, use the website to PDF export.

Turning Competitor Website Screenshots into Actionable Intelligence

Capturing screenshots takes minutes to set up. The real work is turning those captures into decisions.

Pricing change alerts. When a pixel diff exceeds your threshold on a pricing page, trigger a Slack notification to the product team. Include the before and after screenshots in the message so everyone sees the change without clicking through dashboards. Fast pricing responses matter because customers compare competitors side-by-side.

New navigation items or product pages on a competitor's site mean something shipped. Not every feature launch gets a changelog entry. Some show up on the website first, which makes periodic screenshot comparisons of feature pages a reliable tracking method. Monthly captures build a timeline of competitor releases that complements what you learn from social media.

Headline copy changes are subtler but just as telling. If a rival shifts from "Simple screenshot API" to "Enterprise screenshot platform", they're moving upmarket. Screenshot archives make these shifts visible because you can line up homepage captures from six months ago next to today's version.

Regional pricing differences. Use the geolocation parameter to capture competitor pricing from different countries. Some SaaS companies charge different prices in different markets. Capturing the same pricing page from US, EU, and APAC IPs reveals purchasing power parity strategies or regional discounts. Pair this with dark mode captures to see how competitors present their products in both light and dark themes.

curl "https://api.screenshotrun.com/v1/screenshots/capture?url=https://competitor.com/pricing&geolocation=de&block_cookies=true&format=png" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -o competitor-pricing-germany.png

How a Screenshot API Compares to Dedicated CI Tools

Dedicated CI platforms give you dashboards, battlecards, and AI-powered summaries out of the box but charge enterprise prices and lock you into their ecosystem. Visual monitoring tools offer simplicity but cap your checks and give you no rendering control. A screenshot API gives you raw captures with full rendering control: you write the logic, you own the data, and your total spend stays under $10/month. Frankly, most teams paying for enterprise CI tools are overpaying for dashboards they check once a quarter. For a broader overview of the screenshot API market, check the best screenshot API comparison.

We ran the math on one project: tracking 40 competitor pages daily. With ScreenshotRun that's about 1,200 captures a month, well inside the Starter plan. The same coverage on Visualping would have needed the $50/month tier and still wouldn't give us API access.

For teams that already use CI platforms, a screenshot API complements rather than replaces them. Use the API to capture specific pages that your CI tool misses or to feed visual data into your own analysis pipeline.

API Parameters for Competitor Website Monitoring

A note on legality: competitor website monitoring captures publicly visible information. You're not bypassing authentication, scraping private data, or violating access controls. You're taking screenshots of pages any visitor can see. That said, respect robots.txt and keep your capture frequency reasonable.

Keeping tabs on competitors doesn't require an enterprise budget. A screenshot API, a cron job, and a storage bucket deliver visual intelligence that used to cost five figures a year. Start with the pages that matter most, pricing and features, and expand your monitoring list as patterns emerge.

For the technical implementation of visual change detection and pixel diffing, see the website change monitoring guide. If you want to capture competitors' full-page layouts including below-the-fold content, the full page screenshot feature handles infinite scroll and lazy-loaded sections. For teams using AI to analyze competitor screenshots, the screenshots for AI agents guide covers the workflow for feeding captures to vision models. And for generating quick preview cards of competitor landing pages, take a look at link previews.