How to Capture Google Maps Without the Interface

For a single map, use your operating system’s region screenshot tool and keep Google’s attribution visible. For repeatable or automated images without browser controls, use Google Maps Platform’s Maps Static API. It returns a PNG, JPEG, or GIF from an HTTP request and lets you set the center, zoom, size, map type, markers, paths, and styling.

Choose the method that matches your use case:

Need	Best method	Why
One presentation slide or internal note	Manual screenshot	Fastest setup; no API code
Repeatable images in an application	Maps Static API	Deterministic URL-based rendering
Custom labels and drawn regions	My Maps	Supports lines and shapes
Large designed or geographic artwork	Google Earth or Earth Studio	Better export and design controls
Screenshot of an existing map page or workflow	ScreenshotNeo	Automated browser capture with cleanup and usage-based billing

1. Take a one-off screenshot with no browser chrome

This is the quickest way to capture a map for a document, meeting, or personal reference.

1. Open Google Maps and position the map at the required center and zoom.
2. Close side panels, directions cards, and search suggestions that are not part of the map.
3. Use your operating system’s region capture tool. On Windows, use Snipping Tool; on macOS, press Shift-Command-4; on Linux, use the desktop screenshot utility.
4. Crop to the map area while retaining the Google logo, copyright notice, and other required attribution.
5. Save the image in PNG for sharp labels or JPEG when file size matters.

Google’s Geo Guidelines explicitly allow users to capture a screenshot from Google Maps for adding custom labels or graphics. A screenshot does not remove Google’s attribution or grant permission to redistribute map data. Review the applicable Geo Guidelines before publishing.

Make the capture cleaner

• Use the map’s full-screen control when available, then capture only the map.
• Choose a zoom level where labels do not overlap after cropping.
• Capture at the display’s native or retina resolution when the image will be printed.
• Do not erase the Google logo, copyright, or provider attribution during editing.

2. Generate a clean image with Maps Static API

The Maps Static API is Google’s official programmatic route. Google states that it “returns an image (either GIF, PNG or JPEG) in response to an HTTP request.” You construct a URL with parameters such as location, size, zoom, map type, markers, paths, and styling, then use the returned image in an HTML img element or another image request.

An API key is required, and billing must be enabled on the Google Cloud project. Follow Google’s setup guide to enable the API, create a key, and restrict that key.

Basic request

https://maps.googleapis.com/maps/api/staticmap
  ?center=40.7484,-73.9857
  &zoom=14
  &size=800x500
  &maptype=roadmap
  &key=YOUR_GOOGLE_MAPS_API_KEY

Put the request URL directly in an image element:

<img
  src="https://maps.googleapis.com/maps/api/staticmap?center=40.7484,-73.9857&zoom=14&size=800x500&maptype=roadmap&key=YOUR_GOOGLE_MAPS_API_KEY"
  alt="Map centered on Midtown Manhattan"
>

Add a marker

https://maps.googleapis.com/maps/api/staticmap
  ?center=40.7484,-73.9857
  &zoom=14
  &size=800x500
  &markers=40.7484,-73.9857
  &key=YOUR_GOOGLE_MAPS_API_KEY

Request a different map type

Set maptype to the map type supported by the API and your use case. Keep the generated image’s attribution visible wherever Google requires it.

Use paths and styling

The API supports paths for routes or boundaries and styling parameters for changing the visual treatment. URL-encode values when they contain spaces, punctuation, or JSON-like style definitions. Keep the complete request within the API’s documented limits; do not stitch multiple tiles into a larger map.

Python request

from urllib.parse import urlencode
import requests

params = {
    "center": "40.7484,-73.9857",
    "zoom": 14,
    "size": "800x500",
    "maptype": "roadmap",
    "markers": "40.7484,-73.9857",
    "key": "YOUR_GOOGLE_MAPS_API_KEY",
}

url = "https://maps.googleapis.com/maps/api/staticmap?" + urlencode(params)
response = requests.get(url, timeout=30)
response.raise_for_status()

with open("map.png", "wb") as image_file:
    image_file.write(response.content)

Node.js request

const params = new URLSearchParams({
  center: '40.7484,-73.9857',
  zoom: '14',
  size: '800x500',
  maptype: 'roadmap',
  markers: '40.7484,-73.9857',
  key: 'YOUR_GOOGLE_MAPS_API_KEY'
});

const response = await fetch(
  `https://maps.googleapis.com/maps/api/staticmap?${params}`
);

if (!response.ok) {
  throw new Error(`Maps Static API returned ${response.status}`);
}

const image = Buffer.from(await response.arrayBuffer());
await Bun.write('map.png', image);

cURL request

curl -G "https://maps.googleapis.com/maps/api/staticmap" \
  --data-urlencode "center=40.7484,-73.9857" \
  --data-urlencode "zoom=14" \
  --data-urlencode "size=800x500" \
  --data-urlencode "maptype=roadmap" \
  --data-urlencode "markers=40.7484,-73.9857" \
  --data-urlencode "key=YOUR_GOOGLE_MAPS_API_KEY" \
  -o map.png

3. Keep attribution and follow Google’s publishing rules

A clean-looking image still has to follow Google’s terms. Keep the Google logo, copyright notices, and other provider attribution visible. Google’s Maps Platform FAQ says: “You may not store and serve copies of images generated using the Maps Static API from your website.” In practice, use the generated URL so Google serves the image to end users when the documentation requires it, rather than building a permanent image archive on your own server.

• Do not scrape undocumented map tiles or private browser endpoints.
• Do not modify server-side map tiles or stitch static images into a map larger than the documented limits.
• Do not remove attribution when cropping, annotating, or placing the map in a design.
• Check the current Maps Platform Terms and product-specific attribution rules before commercial publication.
• If you display Maps JavaScript results without a map, follow Google’s logo and attribution requirements and provide publicly accessible terms of use and a privacy policy incorporating Google’s requirements.

4. Use My Maps, Google Earth, or Earth Studio for designed maps

If the main goal is annotation rather than a plain screenshot, Google identifies other workflows. My Maps lets you draw lines and shapes on a Google map. Google Earth and Earth Studio can be more suitable when you need an exported geographic composition or a designed animation. Check each product’s attribution and export rules before distributing the result.

5. Or skip the browser setup

ScreenshotNeo captures a URL through a screenshot API, so you can automate an existing Google Maps page or another map workflow without maintaining browser infrastructure. See the ScreenshotNeo API docs for all options.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://www.google.com/maps -o shot.webp

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://www.google.com/maps"}, timeout=90)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://www.google.com/maps' }); const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

Before capture, ScreenshotNeo can accept cookie or consent banners and remove more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be turned off. You can use a custom viewport, retina scale, full-page capture, custom CSS or JavaScript, click an element, wait for a selector or network idle, hide selectors, and set headers, cookies, user agent, timezone, or geolocation. For map pages, use CSS hiding only when it does not remove required Google attribution.

Only clean shots are billed. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and the response identifies the result with X-Page-Verdict and X-Billed headers. ScreenshotNeo also provides an MCP server with take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients. Plans include 1,000 screenshots a month free with no card; paid plans start at $5 for 3,000 shots.

Create a free ScreenshotNeo account to get started.

6. Troubleshooting

Problem	Likely cause	Fix
The static request returns an error image	Missing key, disabled API, or billing is not enabled	Enable Maps Static API, attach billing, and check key restrictions.
The map is cropped or too small	Image dimensions or zoom do not fit the intended layout	Adjust size, center, and zoom; design for the final display size.
Labels overlap	Zoom is too far out or the viewport is too small	Increase image dimensions or zoom in and simplify the displayed area.
Attribution disappeared	Image was cropped or edited too aggressively	Restore the Google logo and copyright/provider notices.
Browser screenshot includes controls	Map was captured from the normal page view	Use full-screen mode and a region capture, or use Maps Static API for repeatable output.
ScreenshotNeo returns a blank or blocked page	The page failed to load, timed out, or presented a bot check	Inspect X-Page-Verdict, increase wait settings, or use the Maps Static API.
Automated images change between runs	Live map labels, viewport, or page state changed	Set a fixed viewport and zoom; cache successful results with a suitable TTL.

7. Performance, reliability, and cost considerations

• Manual screenshots: fastest for one image, but difficult to reproduce exactly.
• Maps Static API: predictable and easy to cache at the URL level; account for API-key, billing, quota, and attribution requirements.
• Browser screenshots: useful when you must capture a rendered page, but page load time, consent dialogs, and bot checks add variability.
• ScreenshotNeo: use caching with a TTL you choose, wait for network idle or a selector when map content loads late, and inspect verdict and billing headers for reliable automation.
• Large batches: generate only the views you need, reuse identical requests, and avoid stitching images outside the documented limits.

FAQ

Can I download a Google map as a picture?

Yes. Take a screenshot for a one-off image or request one from Maps Static API for a programmatic image. Keep required attribution and follow Google’s storage and display rules.

How do I hide Google Maps controls?

For a manual capture, use the map’s full-screen view and crop to the map. For an automated, repeatable image, Maps Static API avoids browser controls entirely.

Can I remove the Google logo?

No. Keep Google’s logo, copyright, and other required attribution visible.

Is Maps Static API the same as scraping map tiles?

No. Maps Static API is Google’s documented image endpoint. Undocumented tile scraping and unauthorized stitching create terms risks.

Which option is best for custom boundaries?

Use Maps Static API paths for programmatic boundaries or My Maps when you need to draw and annotate interactively.