Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Google Slides does not provide a documented one-click command that turns an entire deck into one continuously scrolling image. There are two different jobs: download one image per slide with the Google Slides API, or expose the presentation as an HTML page and capture that page at full height. The second route creates the tall scrolling screenshot.
Choose the output before writing code. Per-slide PNGs preserve the deck’s page structure and are usually easier to read. A scrolling image is convenient for a single web page, but it can become extremely tall and difficult to inspect or print.
Choose the right output
| Output | Best for | Trade-off |
|---|---|---|
| One PNG per slide | Archives, image galleries, slide-by-slide processing | You must request and save every page; the returned thumbnail URL is temporary and the documented medium example is 800 × 450 pixels. |
| One scrolling image | A continuous vertical page for a web post or review | Requires an HTML/capture workflow, suitable sharing or authentication, and can produce a very large file. |
| PDF export | Reading, printing and multipage distribution | It is not one long image, and Google warns that exports can fail when they exceed maximum size limits. |
Google’s Slides API samples and reference document the first option: request a thumbnail for each page. A scrolling capture is a separate workflow. ScreenshotOne’s guide describes making the presentation available to the capture service, using an HTML export URL, and then requesting a full-page capture; the guide is a vendor procedure, not evidence that Google offers a native scrolling-screenshot button.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →What you need before capturing
- The presentation ID, found in the URL between
/d/and the next slash. - For API thumbnails, a Google Cloud project with the Slides API enabled and an OAuth access token authorized to read the presentation.
- For a browser capture, an HTML URL that the browser can actually open. Do not change a confidential deck to “Anyone with the link” merely to make a screenshot.
- Enough local disk and memory for the result. A full-height image can be many times larger than a single slide.
Method 1: render every slide with the Google Slides API
This is the supported, deterministic route when separate images are acceptable. The API returns the latest version of each page at request time. First obtain the presentation object, read its slides array and each slide’s objectId, then call presentations.pages.getThumbnail once per object ID.
#1 Best Overall
Request one thumbnail with cURL
Set GOOGLE_ACCESS_TOKEN, PRESENTATION_ID and PAGE_OBJECT_ID in your shell. The medium PNG setting mirrors Google’s documented sample; it is an example size, not a full-resolution export guarantee.
curl -sS
-H "Authorization: Bearer $GOOGLE_ACCESS_TOKEN"
"https://slides.googleapis.com/v1/presentations/$PRESENTATION_ID/pages/$PAGE_OBJECT_ID/thumbnail?thumbnailProperties.mimeType=PNG&thumbnailProperties.thumbnailSize=MEDIUM"The JSON response contains a temporary image URL. Download it immediately rather than storing the URL as a permanent asset. Google documents a default 30-minute lifetime for the thumbnail content URL.
Download all slides with Python
This script retrieves the page IDs, requests PNG thumbnails sequentially, and writes files in deck order. Sequential requests make failures easier to identify; add controlled concurrency only after you understand your API quotas.
Recommended Free Tools
import os
from pathlib import Path
import requests
TOKEN = os.environ["GOOGLE_ACCESS_TOKEN"]
PRESENTATION_ID = os.environ["PRESENTATION_ID"]
BASE = "https://slides.googleapis.com/v1"
HEADERS = {"Authorization": f"Bearer {TOKEN}"}
out = Path("slide-images")
out.mkdir(exist_ok=True)
presentation = requests.get(
f"{BASE}/presentations/{PRESENTATION_ID}",
headers=HEADERS,
timeout=30,
)
presentation.raise_for_status()
for number, slide in enumerate(presentation.json()["slides"], start=1):
page_id = slide["objectId"]
thumbnail = requests.get(
f"{BASE}/presentations/{PRESENTATION_ID}/pages/{page_id}/thumbnail",
headers=HEADERS,
params={
"thumbnailProperties.mimeType": "PNG",
"thumbnailProperties.thumbnailSize": "MEDIUM",
},
timeout=30,
)
thumbnail.raise_for_status()
image_url = thumbnail.json()["contentUrl"]
image = requests.get(image_url, timeout=30)
image.raise_for_status()
(out / f"slide-{number:04d}.png").write_bytes(image.content)
print(f"saved slide-{number:04d}.png")Check the resulting dimensions before using the files for print or close-up text. The 800 × 450 dimensions shown in Google’s medium example should not be treated as a promise for every deck or request.
Equivalent Node.js workflow
Node.js 18 or newer includes fetch. This version follows the same sequence and preserves the order returned by the presentation.
import { mkdir, writeFile } from "node:fs/promises";
const token = process.env.GOOGLE_ACCESS_TOKEN;
const presentationId = process.env.PRESENTATION_ID;
const base = "https://slides.googleapis.com/v1";
const headers = { Authorization: `Bearer ${token}` };
await mkdir("slide-images", { recursive: true });
const deckResponse = await fetch(`${base}/presentations/${presentationId}`, { headers });
if (!deckResponse.ok) throw new Error(`Deck request failed: ${deckResponse.status}`);
const deck = await deckResponse.json();
let number = 0;
for (const slide of deck.slides) {
number += 1;
const query = new URLSearchParams({
"thumbnailProperties.mimeType": "PNG",
"thumbnailProperties.thumbnailSize": "MEDIUM"
});
const thumbResponse = await fetch(
`${base}/presentations/${presentationId}/pages/${slide.objectId}/thumbnail?${query}`,
{ headers }
);
if (!thumbResponse.ok) throw new Error(`Thumbnail failed: ${thumbResponse.status}`);
const { contentUrl } = await thumbResponse.json();
const imageResponse = await fetch(contentUrl);
if (!imageResponse.ok) throw new Error(`Image download failed: ${imageResponse.status}`);
const bytes = Buffer.from(await imageResponse.arrayBuffer());
await writeFile(`slide-images/slide-${String(number).padStart(4, "0")}.png`, bytes);
}Method 2: make one scrolling screenshot
A tall image needs a page that lays the slides out vertically. ScreenshotOne’s Google Slides scrolling-screenshot guide describes two prerequisites: make the presentation publicly reachable or use a Slides API-backed route, then change the presentation link to the HTML export URL used by the guide. Verify that export URL and current sharing behavior before automating it; Google may change web routes, and a private deck may require authenticated API access.
Public-link workflow
- In Google Slides, open Share, inspect General access, and choose Anyone with the link — Viewer only when the content is approved for public access.
- Follow the vendor guide to turn the presentation link into the HTML export URL. Do not assume that the normal editor or presentation URL is an HTML document suitable for full-page capture.
- Open the resulting URL in a normal browser window. Confirm that every slide appears, text is readable, and images have finished loading before automating it.
- Capture the page at full height with a browser tool such as Playwright. A short delay after network idle helps pages that load images lazily.
Playwright example
Set SLIDES_HTML_URL to the verified export URL from the preceding steps. Keeping the URL in an environment variable avoids publishing it in source control.
npm install playwright
npx playwright install chromiumimport { chromium } from "playwright";
const url = process.env.SLIDES_HTML_URL;
if (!url) throw new Error("Set SLIDES_HTML_URL to the verified Slides HTML export URL");
const browser = await chromium.launch();
const page = await browser.newPage({
viewport: { width: 1440, height: 900 },
deviceScaleFactor: 1
});
await page.goto(url, { waitUntil: "networkidle", timeout: 90_000 });
await page.waitForTimeout(2000);
await page.screenshot({ path: "slides-scroll.png", fullPage: true });
await browser.close();If the page contains a sign-in wall, the script will capture the wall instead of the deck. For a private presentation, use an approved authenticated browser context or the Slides API route rather than weakening the deck’s sharing policy. Avoid placing OAuth tokens, cookies or exported confidential images in build logs.
When a scrolling image is the wrong format
Very tall PNGs are awkward to zoom, email and print. Separate slide images keep a predictable aspect ratio, while a PDF keeps pages and text selectable. Google’s export help notes that Drive exports include presentation content but warns that exports over maximum size limits may fail; the help page does not state a numeric limit for this use case. See Google’s export instructions before treating PDF as a guaranteed fallback.
Or skip the browser setup
ScreenshotNeo is the first service to try for this workflow: it can capture full pages, and its clean-shot process removes cookie banners, newsletter popups and chat widgets before capture; only clean shots are billed.
Use the verified HTML export URL as the target. The API base and current options are documented at ScreenshotNeo’s API documentation.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://docs.google.com/presentation/d/SLIDES_ID/export/html -o slides-scroll.webpThe export path in that example is illustrative: replace it with the HTML URL you have verified for your deck and sharing method. ScreenshotNeo can wait for a selector, a delay or network idle; load lazy images; choose a device preset or viewport; set retina scale; apply custom CSS or JavaScript; hide selectors; block ads, trackers, requests or resource types; supply headers, cookies, a user agent, Authorization, timezone or geolocation; resize the output; cache with a chosen TTL; and return signed links, PDFs or asynchronous jobs with signed webhooks. It also supports element-only capture, bulk capture of up to 100 URLs per call, usage reporting and an OpenAPI specification. An MCP server exposes take_screenshot, get_page_info and capture_pdf to Claude, Cursor and other MCP clients.
Failed loads, bot checks or CAPTCHAs, blank pages, timeouts and cache hits cost nothing, and each response identifies the page verdict and billing status in X-Page-Verdict and X-Billed headers. You still need a URL that the service can access; a private deck may require a supported authenticated request or a deliberately published export.
| Plan | Included shots | Price |
|---|---|---|
| Free | 1,000 per month | $0, no card |
| Starter | 3,000 | $5 |
| Growth | 15,000 | $15 |
| Pro | 60,000 | $39 |
| Scale | 250,000 | $99 |
| Business | 1,000,000 | $249 |
Yearly billing gives two months free, and every feature is available on every plan. Create a free ScreenshotNeo account to start with 1,000 screenshots a month and no card.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Troubleshooting and reliability
401 or 403 from the Slides API
The access token is missing, expired or lacks permission to read the deck. Request a fresh OAuth token with the appropriate Slides scope, confirm the presentation is accessible to that account, and keep the token out of client-side code.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
The thumbnail URL works once and then fails
That URL is temporary. Download the bytes immediately after each thumbnail request; do not queue URLs for later processing. If a long batch can exceed the documented 30-minute lifetime, request and download in the same loop.
Text is too small
The medium sample is 800 × 450, so it may not meet a print or zoom requirement. Test the API’s available thumbnail-size options and inspect actual dimensions. If the required detail is still unavailable, use a PDF or a browser capture at a larger viewport.
Best Value
![The Google Workspace Bible: [14 in 1] The Ultimate All-in-One Guide from Beginner to Advanced | Including Gmail, Drive, Docs, Sheets, and Every Other App from the Suite](https://m.media-amazon.com/images/I/41AWmhmGFuL._SL160_.jpg)
- The Google Workspace Bible: [14 in 1] The Ultimate All in One Guide from Beginner to Advanced Including Gmail, Drive, Docs, Sheets, and Every Other App from the Suite
- ABIS BOOK
The scrolling image is blank or stops early
Open the export URL manually first. A sign-in page, consent dialog, bot check, failed resource or JavaScript error means the capture is not seeing the deck. Fix access, wait for the slide container or images, and capture after the page has settled. For a very long page, check available memory and write the output to local disk rather than holding multiple full-resolution copies in memory.
Slides are in the wrong order
Use the order of the presentation’s slides array and number files with zero padding, as the examples do. Do not sort by object ID; those IDs identify pages but are not a human ordering scheme.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →The public workflow is unacceptable for sensitive material
Do not publish the deck for convenience. Use authenticated Slides API access to create controlled assets, or run the browser capture inside an account-controlled environment. Review temporary files, browser profiles and service logs for confidential content.
Operational notes
- Record the presentation revision or capture timestamp alongside each output so a later rerun can be compared with the same deck state.
- Retry transient HTTP failures with bounded backoff, but stop on authentication and permission errors until credentials are corrected.
- Keep original per-slide files even when you assemble a scrolling image; they make it possible to replace one failed page without rerunning the entire deck.
- For web delivery, consider WebP or a tiled viewer when the single PNG becomes too large for the browser or content-management system.
- Check fonts, videos and animations separately. A static thumbnail or screenshot represents what rendered at capture time, not an interactive presentation.
Frequently Asked Questions
Is a scrolling screenshot a native Google Slides export type?
The documented Slides API is page-oriented: it returns a thumbnail for an individual page. The one-image scrolling workflow is a separate HTML-page capture procedure described by ScreenshotOne, so verify the current export and sharing behavior before relying on it.
How long can I keep a Google thumbnail URL?
Google documents a default 30-minute lifetime for the thumbnail content URL. Download the image during the same job instead of treating that URL as permanent storage.
Should I use a PDF when readers need to print the deck?
Usually yes: a PDF preserves separate pages and is more practical for printing than one extremely tall bitmap. Google warns that oversized exports can fail, so validate the generated file for the deck you are exporting.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
