How to Save SERP Screenshots with Keyword and Location Filenames

Use a consistent filename that records the search engine, device, keyword, intended location, capture date, and—when it matters—time and timezone. For example: google_desktop_best-plumber_queens-ny_2026-10-03_14-30_UTC.png. Set the search location before capturing: putting a city in the filename helps you retrieve the file, but does not make the search geographically targeted.

1. Choose a filename pattern

A practical pattern is:

{engine}_{device}_{keyword}_{location}_{YYYY-MM-DD}_{HH-MM}_{timezone}.png

Include the fields you need to identify a capture and compare it fairly with another one. If time of day does not matter to your work, omit the time and timezone. If you capture only one engine or device, you may not need those fields in every filename, but record them somewhere.

Field	Example	Why keep it
Engine	`google`	Separates captures from different search engines.
Device	`desktop`, `mobile`	Results and layout can vary by device.
Keyword	`best-plumber`	Makes the file searchable by query.
Location	`queens-ny`	Identifies the intended geographic target.
Date and optional time	`2026-10-03_14-30`	Sorts captures chronologically and distinguishes repeated captures.
Timezone	`UTC`, `America-New_York`	Clarifies what a recorded time means.

Use a stable order, lowercase where practical, hyphens between words, and underscores between fields. Use an ISO-style year-month-day date so names sort chronologically. Keep a separate record for details that do not fit well in a filename, such as the exact location setting, language, search URL, capture method, or notes about the SERP.

2. Set the target location and capture conditions

Choose the engine and configure the actual location targeting method before opening or capturing the SERP. Local results can vary with location; a location label in a filename is recordkeeping, not targeting.
Record the exact target and how it was set, along with language and device. If you are comparing changes over time, keep these conditions consistent.
Decide whether you need the visible viewport or the full page. A viewport capture is quicker and may be enough to record the first screen. Use a full-page capture when you need results farther down the page. Full-page captures can include dynamically loaded content, so check that the finished image contains what you intended.
Capture the page, then rename the file using your chosen pattern. Confirm the extension matches the actual image format.

For example, a manual browser workflow might produce google_mobile_best-plumber_queens-ny_2026-10-03_14-30_UTC.png. Save a small sidecar note or CSV row if the filename cannot capture the precise targeting method or other conditions.

3. Make filenames safe and consistent

Replace spaces with hyphens or underscores, and use the same rule every time.
Replace or remove filesystem-sensitive punctuation, such as slashes, colons, question marks, and quotation marks. A query like plumber near me? could become plumber-near-me.
Keep names reasonably short. Preserve the meaningful query rather than adding every search term or note to the filename.
Use a consistent location spelling and granularity, such as queens-ny or london-uk. Avoid silently changing between neighborhood, city, and country labels.
Do not overwrite a previous capture. Include a time, sequence number, or other unique suffix if more than one capture can happen on the same date.
Use the correct extension, such as .png, .jpg, or .webp. A renamed extension does not convert the underlying image.

Descriptive filenames help you find and manage evidence. Google’s guidance about image filenames concerns images published on the web: it says filenames can offer “very light clues” about an image’s subject. That is not evidence that naming private SERP screenshots affects search rankings. See Google’s image SEO guidance.

4. Find and compare old captures

Keep captures in a predictable folder structure, for example:

serp-captures/
  google/
    desktop/
      2026/
        google_desktop_best-plumber_queens-ny_2026-10-03_14-30_UTC.png

You can also keep all images together and search by filename; choose one approach and apply it consistently. For a comparison, match the engine, keyword, intended location, device, language, and approximate capture time. If one of those changed, note it instead of treating the images as directly equivalent.

A simple CSV index can make a large archive easier to search:

filename,engine,keyword,target_location,location_method,device,language,captured_at,timezone,notes
google_desktop_best-plumber_queens-ny_2026-10-03_14-30_UTC.png,google,best plumber,Queens NY,configured search location,desktop,en,2026-10-03 14:30,UTC,full page

Keep the exact search URL or other targeting details in the index if needed. Treat filenames and screenshots as potentially sensitive if they reveal search terms, client locations, or account-specific results; store and share them accordingly.

5. Choose a capture workflow

There are three common approaches:

Approach	Useful when	Check before relying on it
Manual browser capture and rename	You need occasional captures and control over the browser context.	Whether you captured the viewport or full page, and whether the target location was actually configured.
Browser extension	You want capture and filename construction in one flow.	Full-page support, filename tokens, target-location handling, export behavior, and data/privacy terms.
Rank-tracking service	You want screenshots associated with tracked keywords and measurements.	Location and device settings, export options, retention period, and what the screenshot represents.

These approaches are not directly comparable without checking their current documentation and settings. For example, SERPshot’s listing describes full-page SERP capture and configurable filename tokens. BrightLocal says its Local Rank Tracker screenshots are stored for 45 days, while SerpWatch’s documentation describes a 10-day ranking verification window. These are vendor-specific retention statements, not a general guarantee; check current product documentation before depending on hosted history. See SERPshot’s browser listing, BrightLocal help, and SerpWatch support.

6. Automate capture with a browser in Python

For repeated captures, a browser automation script can take the screenshot and construct the filename from the same metadata you record. The example below uses Playwright. Install the package and browser once:

python -m pip install playwright
python -m playwright install chromium

Save this as capture_serp.py. It captures a page URL you supply; it does not configure a search engine’s geographic targeting for you. Set the location in the search page or service first, then pass the resulting URL and accurate metadata.

import argparse
import re
from datetime import datetime
from pathlib import Path
from zoneinfo import ZoneInfo
from playwright.sync_api import sync_playwright


def safe_part(value: str) -> str:
    value = value.strip().lower()
    value = re.sub(r"[^a-z0-9]+", "-", value)
    return value.strip("-") or "unknown"


parser = argparse.ArgumentParser()
parser.add_argument("url", help="SERP URL after configuring the intended location")
parser.add_argument("--engine", default="google")
parser.add_argument("--device", default="desktop")
parser.add_argument("--keyword", required=True)
parser.add_argument("--location", required=True, help="Human-readable intended target, not proof of targeting")
parser.add_argument("--timezone", default="UTC", help="IANA timezone, for example UTC or America/New_York")
parser.add_argument("--full-page", action="store_true")
args = parser.parse_args()

zone = ZoneInfo(args.timezone)
now = datetime.now(zone)
stamp = now.strftime("%Y-%m-%d_%H-%M")
filename = "_".join([
    safe_part(args.engine),
    safe_part(args.device),
    safe_part(args.keyword),
    safe_part(args.location),
    stamp,
    safe_part(args.timezone.replace("/", "-")),
]) + ".png"

Path("serp-captures").mkdir(parents=True, exist_ok=True)
with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page(viewport={"width": 1365, "height": 900}, device_scale_factor=1)
    page.goto(args.url, wait_until="domcontentloaded", timeout=60000)
    page.screenshot(path=str(Path("serp-captures") / filename), full_page=args.full_page)
    browser.close()
print(Path("serp-captures") / filename)

Run it with a URL and metadata that match the capture:

python capture_serp.py 'https://www.google.com/search?q=best+plumber' \
  --keyword 'best plumber' --location 'Queens NY' --device desktop \
  --timezone UTC --full-page

This example records the intended target supplied on the command line. Add the location through the method appropriate to your SERP workflow, and store that exact method in an index when it matters. The example uses a fixed viewport; change the width and height if you need a different layout, and keep them stable for longitudinal comparisons.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. Its one-call API is useful when you want a screenshot without managing a browser installation. It captures the URL you provide; set the intended location on the search page or in the supported request context and record that method in your filename or metadata. It does not make a filename’s location label into geographic targeting.

See the ScreenshotNeo API documentation for request options. This cURL example saves an image response:

curl -G "https://api.screenshotneo.com/v1/shot" \
  -d access_key=YOUR_API_KEY \
  --data-urlencode url=https://www.google.com/search?q=best+plumber \
  -o shot.webp

Equivalent Python:

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={
        "access_key": "YOUR_API_KEY",
        "url": "https://www.google.com/search?q=best+plumber",
    },
    timeout=90,
)
r.raise_for_status()
open("shot.webp", "wb").write(r.content)

Equivalent Node.js:

const q = new URLSearchParams({
  access_key: 'YOUR_API_KEY',
  url: 'https://www.google.com/search?q=best+plumber'
});
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
await Bun.write('shot.webp', new Uint8Array(await res.arrayBuffer()));

Rename the saved file with the same pattern, and use the response format you requested when choosing its extension. ScreenshotNeo removes cookie banners, newsletter popups, and chat widgets before capture; bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 screenshots. Sign up for free screenshots.

Troubleshooting

Problem	Likely cause	Fix
The file is difficult to find later	Names use inconsistent field order or location spelling.	Adopt one pattern, normalize values, and keep a searchable index.
The filename says one city but the results look different	The city was only written into the filename; the search itself was not location-targeted, or another condition changed.	Configure the actual target before capture and record the method, language, and device.
Two captures overwrite each other	Both were saved under the same name.	Add time, sequence, or a unique capture identifier; do not overwrite historical evidence.
Image will not open after renaming	The extension does not match the encoded image format.	Use the true format extension or convert the image before changing the extension.
Screenshot misses content lower on the page	Only the viewport was captured, or content had not loaded when the screenshot ran.	Enable full-page capture where appropriate and wait for the needed content before capturing.
Automated capture times out	The SERP or its resources did not finish loading before the timeout.	Check the URL and connectivity, allow more time, and consider waiting for the page’s useful content rather than every network request.
Python reports an unknown timezone	The timezone value is not an installed IANA name or the system timezone database is unavailable.	Use a valid name such as `UTC` or `America/New_York`; install timezone data if the platform needs it.

Performance, reliability, and cost

Performance: Viewport captures are generally smaller and simpler than full-page captures. Full-page images can use more memory and take longer on long pages. Keep the viewport and capture mode consistent when comparing results.
Reliability: Record the URL, target-setting method, device, language, timestamp, and capture mode. A screenshot is a record of one rendered page at one time; it does not establish that the same results will appear for every user.
Storage: Use a predictable archive and back it up if the captures are evidence you need to retain. Hosted screenshot retention varies by vendor and plan, and may change.
Cost: Manual captures avoid API usage charges but require human time and local organization. Extensions and rank trackers may have their own pricing and retention terms; verify current terms. ScreenshotNeo offers 1,000 shots a month free with no card, then paid plans from $5 for 3,000; only clean shots are billed, and its response identifies the page verdict and billing status.

FAQ

Does adding a city to the filename change Google results?

No. It labels the file for retrieval. Configure the actual search location separately.

Should I include the exact keyword?

Include enough of the query to recognize it. Normalize punctuation and whitespace, and keep the full query in a sidecar index if shortening it would cause ambiguity.

How do I find an old screenshot for a keyword?

Search the keyword portion of a consistent filename or query your CSV index. Include location and date to distinguish repeated captures.

Can a screenshot filename improve rankings?

There is no evidence here that filenames of private SERP captures affect rankings. Google’s filename guidance is about published images.

Sources

Google Search Central: Google Images best practices — filename guidance for published images.
Moz Help Hub — SERP export fields include keyword, location, and SERP date.
SerpWatch — location, language, device, and screenshot verification documentation.
BrightLocal Help — vendor-specific screenshot retention information.