How to Track Screenshot Changes on Indian Insurance Websites

To track visible changes on Indian insurance websites, capture each public page on a schedule, retain an identified baseline, and compare every later screenshot against it. You can use a hosted visual-monitoring service or build the workflow with Playwright Test. A screenshot records what a page looked like at a particular time; by itself, it does not explain why the page changed, establish when policy terms became effective, or prove a legal violation.

1. Choose what to monitor

Start with a list of public insurer pages tied to a clear question. Depending on your needs, these could include product descriptions, policy wording, premium or rate information, exclusions, claims instructions, or service pages. Record the exact URL for each page and why it matters.

Decide whether each monitor is primarily about visible wording and numbers, or about layout and imagery. If wording matters, pair screenshot comparison with extracted text or a text diff. Small changes to a figure, date, or exclusion can be difficult to notice in a full-page image.

2. Establish a baseline and consistent capture conditions

The first capture is your baseline. Store it with enough context to reproduce and interpret it later:

Exact page URL and capture time in UTC.
Viewport width and height, browser name and version, operating system, and relevant rendering settings.
The original screenshot and, when useful, visible page text.
A stable page state, such as whether a consent dialog was accepted and whether a menu or accordion was open.

Keep the environment consistent between the baseline and later captures. Browser version, host OS, hardware, headless mode, and other rendering conditions can affect screenshots. If you change the browser or viewport, create a new baseline or treat the transition as a known environment change.

3. Implement scheduled captures with Playwright Test

Playwright Test can create screenshot reference files on the first run and compare later runs with them. The following minimal setup captures a page and checks it against a committed baseline.

npm init -y
npm install --save-dev @playwright/test
npx playwright install chromium

Create tests/insurance-pages.spec.js:

const { test, expect } = require('@playwright/test');

test('public insurance page matches its visual baseline', async ({ page }) => {
  await page.setViewportSize({ width: 1365, height: 900 });
  await page.goto('https://example.com/insurance/product', {
    waitUntil: 'networkidle',
    timeout: 60000,
  });
  await expect(page).toHaveScreenshot('insurance-product.png', {
    fullPage: true,
    animations: 'disabled',
    maxDiffPixelRatio: 0.01,
  });
});

Replace the example URL with a public page you are authorized to access. Create a playwright.config.js file:

module.exports = {
  testDir: './tests',
  use: {
    browserName: 'chromium',
    headless: true,
  },
  expect: {
    toHaveScreenshot: {
      threshold: 0.2,
    },
  },
};

On the first run, Playwright writes the reference screenshot. Review it and commit it as the known baseline. Subsequent runs compare the rendered page to that reference and report differences. Run the test on a schedule using your CI system or job scheduler; the schedule mechanism is infrastructure-specific.

Useful Playwright controls

fullPage: true captures the full document; omit it to capture the viewport.
animations: 'disabled' reduces variation from animations and transitions.
threshold controls per-pixel color sensitivity; a more tolerant threshold ignores subtle rendering noise.
maxDiffPixelRatio permits a bounded ratio of differing pixels before the assertion fails.
stylePath can apply a stylesheet during screenshot comparison to hide or neutralize known dynamic regions.
mask can cover specific locators that change predictably, such as a rotating promotional image.

Use masks and styles selectively. Never conceal policy wording, amounts, dates, exclusions, or another region whose change is the reason for monitoring the page. Tune tolerances against known harmless rendering variation, then inspect every reported change that could affect the monitored question.

Add a text snapshot for wording changes

For pages where wording matters, save visible text alongside the screenshot. This example writes a text observation on each run; in a production monitor, retain it with the timestamp and compare it with the prior observation.

const fs = require('node:fs/promises');
const { test, expect } = require('@playwright/test');

test('capture insurance page and visible text', async ({ page }) => {
  await page.setViewportSize({ width: 1365, height: 900 });
  await page.goto('https://example.com/insurance/product', {
    waitUntil: 'networkidle',
    timeout: 60000,
  });
  await expect(page).toHaveScreenshot('insurance-product.png', {
    fullPage: true,
    animations: 'disabled',
  });
  const text = await page.locator('body').innerText();
  await fs.writeFile('insurance-product.txt', text, 'utf8');
});

A text diff can make a changed number or sentence easier to find, while the screenshot preserves layout and visual context. Keep both observations linked to the same URL and capture time.

4. Choose between a hosted monitor and self-managed capture

Consideration	Hosted visual monitor	Self-managed Playwright
Setup	Usually configure URLs and monitor settings in the service; exact setup varies.	Write tests, manage browser infrastructure, baselines, storage, and alerts.
Scheduling and alerts	Services advertise scheduled captures and notifications; verify current cadence, alert channels, and limits.	Integrate with your CI or job scheduler and notification system.
Noise controls	Capabilities vary; check thresholds, region controls, and ignored-element behavior.	Configure tolerances, animation handling, masks, or stylesheet filtering in the test workflow.
Evidence and retention	Check export, history, access control, retention, data location, and contractual terms directly.	You control where baselines and captures are stored and how long they are retained.
Best fit	Teams that want managed schedules and alerting with less browser-infrastructure work.	Teams that already operate browser automation and need control over the capture pipeline.

Compare providers on actual capture cadence, rendering consistency, viewport and region support, noise controls, alerting, history, storage, retention, and total cost. Verify the current plan details directly; vendor features and limits can change.

5. Review and preserve each change

Keep the old and new screenshots, capture times, URL, and generated diff together.
Inspect the changed region at readable scale. Determine whether it is wording, a number or date, layout, imagery, a temporary banner, or a rendering artifact.
For policy wording or amounts, compare the observation with the insurer’s dated policy document and relevant current official sources.
Record your interpretation separately from the raw capture. Preserve the original files so another reviewer can reach their own conclusion.

A screenshot is an observation of a rendered page at capture time. It does not alone establish the change’s cause, legal meaning, effective date, or compliance implications. The research reviewed for this guide did not establish an IRDAI requirement to monitor insurance websites with screenshots.

6. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. One GET request can return an image or PDF; see the ScreenshotNeo API documentation for options and response details.

curl -G "https://api.screenshotneo.com/v1/shot" \
  -d access_key=YOUR_API_KEY \
  --data-urlencode url=https://example.com/insurance/product \
  -o insurance-product.webp

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={
        "access_key": "YOUR_API_KEY",
        "url": "https://example.com/insurance/product",
    },
    timeout=90,
)
r.raise_for_status()
open("insurance-product.webp", "wb").write(r.content)

const q = new URLSearchParams({
  access_key: 'YOUR_API_KEY',
  url: 'https://example.com/insurance/product',
});
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
const image = Buffer.from(await res.arrayBuffer());
await import('node:fs/promises').then(fs =>
  fs.writeFile('insurance-product.webp', image)
);

For repeat monitoring, schedule the request and retain each successful capture with its URL and UTC timestamp. ScreenshotNeo accepts cookie and consent banners and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each cleanup step can be turned off. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers identify the page verdict and billing status. Its MCP server includes tools for screenshots, page information, and PDFs, for use with Claude, Cursor, or another MCP client. The free plan includes 1,000 shots per month without a card; paid plans start at $5 for 3,000 shots.

Performance, reliability, and cost

Cadence: More frequent checks can observe a change sooner, but increase capture volume and the number of alerts you must review. Choose a schedule based on how quickly you need to notice a change.
Rendering stability: Pin browser and operating-system versions where possible, keep viewport and page state stable, and control animation. Treat environment upgrades as possible baseline changes.
Page readiness: Network-idle waits can time out on pages with persistent network activity. If that happens, wait for a meaningful selector or a deliberate short delay, and keep the same readiness rule across runs.
Retention: Screenshots accumulate. Define access, retention, backup, and deletion rules that fit your evidence needs and data-handling requirements.
Cost: Self-managed capture has infrastructure and maintenance costs; hosted services charge according to their plans and limits. Compare total cost at your expected schedule and number of pages, and include review time in the estimate.

Troubleshooting

Symptom	Likely cause	What to do
Every run reports a large diff	Browser, OS, viewport, fonts, page state, or rendering mode changed.	Restore the baseline environment and viewport; if the change is intentional, review and create a new baseline.
Small diffs recur on dates, banners, or rotating content	The page contains dynamic values or temporary content.	Use a targeted mask or stylesheet for regions irrelevant to your question. Keep monitored wording and figures visible.
Navigation times out waiting for network idle	The page keeps polling or loading resources.	Wait for a stable content selector or use a consistent readiness condition that matches the page.
Screenshot is blank or incomplete	The page had not rendered its content, content is lazy-loaded, or a bot check interrupted the visit.	Check the page manually, wait for the relevant content, and classify bot checks separately from page changes.
Text changed but the image diff is hard to read	The affected text is small or the change occupies few pixels.	Compare extracted visible text and zoom into the relevant image region.
Alerts arrive too often	Tolerances are too strict or irrelevant dynamic regions are included.	Adjust thresholds carefully and filter only known noise; review a sample of suppressed changes to ensure material content remains detectable.
A screenshot differs after a baseline update	The reference file changed or was regenerated.	Review the baseline change, retain the prior version where your process requires it, and record why the new reference was accepted.

FAQ

Can a screenshot prove that an insurer changed a policy?

It can document what the public page displayed at a capture time. Confirm consequential wording against dated policy documents and applicable official sources.

Should I capture only the policy page?

Monitor the pages that answer your question. Depending on the topic, a product, exclusions, rates, claims, or service page may also matter.

How often should I capture a page?

Set the interval according to how quickly you need to detect a visible change and how much review volume you can handle. There is no universally correct cadence.

Choose a consistent page state. If the banner obscures content, configure the capture to reach the content consistently and record that choice with the baseline.