How to Capture a Website Screenshot on Android at 1x Device Scale

For a quick record of what is visible on an Android phone, use its built-in screenshot control. For a website-only image with a controlled mobile viewport and an explicit 1x capture scale, use Chrome DevTools: enable device mode, set the viewport, set the device scale factor to 1, then capture the viewport or full page. If the image must show how the site renders on a particular physical phone, connect it to desktop Chrome with remote debugging.

Here, “1x” means the capture workflow’s device scale factor is set to 1. It does not mean CSS pixels always equal physical screen pixels on every Android device: viewport and device density are separate factors.

1. Choose the capture method

Method	Use it when	Scale and framing	Trade-off
Android screenshot	You need a quick record of what appears on the phone.	Captures the device screen.	May include browser controls and Android interface; no web-only scale control is implied.
Scrolling screenshot, if supported	You need more than one screen of content from the phone.	Device-specific scrolling capture.	Availability and controls vary by handset and OS; check for repeated or missing content.
Chrome DevTools device mode	You need a website-only image at a chosen mobile viewport and explicit 1x capture scale.	Emulated viewport; choose viewport or full-page output.	Emulation is not a physical Android device.
Remote debugging	You need to inspect a page running on a real Android phone.	Desktop DevTools inspects the live device tab.	Requires phone and computer setup.

2. Take a screenshot on the Android phone

Open the website in the Android browser and scroll to the part you need.
Use the phone’s screenshot control. The exact controls vary by manufacturer and OS version, so follow the device’s own instructions.
If the phone offers a scrolling screenshot, use it to extend the capture, then review the result for repeated or missing sections.

This is the quickest way to record the screen as seen on the device. It is not the right choice when you need a clean page image at a specified viewport and scale: browser chrome or system interface may be included, and the screenshot control does not provide DevTools-style web capture settings.

3. Capture a website at 1x with Chrome DevTools

Device mode simulates a mobile device in desktop Chrome. Set both the viewport and capture scale deliberately; a device preset alone does not establish that the screenshot scale is 1x.

Open the target page in desktop Chrome and open DevTools.
Enable device mode, then choose a device preset or enter the viewport dimensions you need. Record the viewport dimensions if the image must be reproducible.
In the device emulation controls, set or verify the device scale factor as 1. The Chrome DevTools Protocol documents a device scale factor override and page screenshot capture.
Wait for the page to render. Check that fonts, images, and any content that appears after scrolling have loaded.
Use DevTools’ screenshot capture options. Capture the visible viewport for the screen currently shown, or choose a full-size screenshot for the whole page. Chrome documents these as distinct capture results.
Open the exported file and inspect its dimensions and edges. Confirm that the page content and framing match the intended viewport; do not infer 1x from sharpness alone.

DevTools’ menu labels can change across Chrome versions. If you do not see the capture option where expected, open the DevTools command menu and search for screenshot capture commands, or consult Chrome’s device mode guide and screenshot instructions.

Viewport versus full-page image

Viewport capture: saves the visible browser viewport. Use it when you want one mobile screen or a particular scroll position.
Full-page capture: includes page content beyond the visible viewport. Use it for a whole-page record, and inspect the output for content that loads only on scroll.

A full-page capture can be substantially taller than the viewport. If the page uses lazy-loaded images or content that appears only after interaction, scroll through the page first and check the result rather than assuming every section loaded.

4. Capture a real Android browser tab with remote debugging

Use remote debugging when the screenshot needs to reflect a page actually running on the phone, rather than DevTools’ emulation. Chrome’s remote debugging guide describes connecting desktop DevTools to an Android device.

Enable the debugging setup required by the phone and Chrome, following the official remote debugging instructions.
Connect the phone to the computer and open the target website in Chrome on the phone.
Open desktop Chrome’s remote-device inspection view and select the live tab.
Inspect the page at its actual device viewport. Capture the visible viewport or use the available page screenshot workflow as appropriate.

A data-capable USB cable may be useful for this optional setup; it must support data transfer and be compatible with the phone. A cable is not needed for an ordinary on-phone screenshot.

5. Understand what 1x does—and does not—mean

In this workflow, 1x is an explicit device scale factor setting for the emulated capture. It is distinct from the Android display’s physical pixel density. Android browser scaling and viewport settings affect how web content is laid out, so setting a scale factor to 1 does not make every phone’s physical pixels correspond one-to-one with CSS pixels.

For repeatable results, note the URL, viewport width and height, device scale factor, whether the capture is viewport or full page, and whether it was made with emulation or a real phone. Compare image dimensions and page framing when checking two captures.

6. Troubleshooting

Symptom	Likely cause	What to do
The image includes browser bars or Android controls.	You used the phone’s screen screenshot.	Use DevTools for a website-only capture, or crop the screen image if the surrounding interface is acceptable.
The output is not the dimensions you expected.	The viewport, device scale factor, or capture mode differs from your expectation.	Verify viewport dimensions and scale factor, then distinguish viewport capture from full-page capture. Inspect the exported image dimensions.
The page looks different from the physical phone.	Device mode is emulation, not a real phone.	Use remote debugging to inspect the live Android tab when real-device rendering matters.
Content is missing in a full-page image.	Some content may load only after scrolling, or the page may not have finished rendering.	Scroll through the page, wait for the content, and capture again. Inspect the exported image for gaps.
A scrolling screenshot has duplicated or missing sections.	The phone’s scrolling capture is device-specific and may not handle the page cleanly.	Review the result; try DevTools full-page capture for a controlled website-only image.
The phone does not appear for remote inspection.	Remote debugging setup or the connection is incomplete.	Check the phone and desktop setup against Chrome’s remote debugging instructions, and use a compatible data-transfer connection.

7. Performance, reliability, and cost

The on-phone screenshot is the shortest workflow when you only need the visible screen. DevTools adds setup but gives you control over emulated viewport, capture scale, and viewport versus full-page framing. Remote debugging adds connection and device setup but lets you inspect the actual phone browser. For long or dynamic pages, allow content to load and inspect full-page output because lazy content can otherwise be absent.

The built-in phone screenshot and Chrome DevTools workflows described here do not require a screenshot API subscription. A screenshot API is useful when you need repeatable captures in code, automation, or an AI-agent workflow; the cost then depends on the service and plan.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. Its API returns a screenshot or PDF from one GET request. Cookie banners, newsletter popups, and chat widgets are removed before capture; bot checks, blank pages, and failed loads are never billed. An MCP server lets AI agents use the take_screenshot, get_page_info, and capture_pdf tools. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000.

Install the Python dependency with python -m pip install requests, set your API key, then run:

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
r.raise_for_status()
with open("shot.webp", "wb") as image:
    image.write(r.content)

For the equivalent cURL request:

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

And with Node.js, using the built-in fetch:

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

Replace https://stripe.com with the page you want to capture and replace the placeholder with your API key. See the ScreenshotNeo API documentation for options, including mobile viewport and scale settings. Create a free account for 1,000 screenshots a month with no card.

FAQ

How do I take a screenshot of a website on Android?

Use the phone’s screenshot control for the screen as displayed. Use Chrome DevTools when you need a clean website-only capture with controlled viewport settings.

Can I capture the whole page at 1x?

Yes. In DevTools, set the device scale factor to 1 and choose the full-size page screenshot. Check that lazy content has loaded and inspect the output.

Does 1x mean CSS pixels equal physical pixels on every Android phone?

No. The 1x setting is the capture workflow’s device scale factor. Android device density and browser viewport behavior are separate.

Is Chrome DevTools device mode the same as using an Android phone?

No. Device mode simulates a mobile setup. Use remote debugging if the page must run on the physical phone.