Your files never leave your device. All processing happens locally in your browser.
How do I put a screenshot inside a phone or laptop frame for free without uploading it?
Open the Device Mockup Generator, drop in a screenshot, then pick a device frame (phone with a notch, punch-hole or classic bezels, a tablet, a clamshell laptop, a desktop monitor, a browser window, or a smart watch), a metal finish, portrait or landscape, and a “cover” or “contain” fit. Add a local gradient, solid or transparent background, a drop-shadow and padding, and pan / zoom the screenshot to frame it. A live preview updates as you go, and you export a crisp PNG at 1×, 2× or 3× — the whole scene is composited with the Canvas 2D API on your device, so the screenshot is never uploaded.
A device mockup generator places a screenshot inside a picture of a device — a phone, tablet, laptop, monitor, browser window or watch — to present an app or website in a realistic context for stores, landing pages and portfolios. A client-side generator does all the work in the browser: the frame geometry is expressed in normalised coordinates, the screenshot is fitted to the screen rectangle with object-fit semantics (cover or contain), clipped to the screen’s rounded corners, and the frame, background, notch, stand and shadow are painted with the HTML5 Canvas 2D API, then exported to a PNG via canvas.toBlob(). Exporting at 2×/3× the base size keeps the raster sharp on high-DPI displays.
No. Your screenshot is read locally with the browser’s FileReader into an in-memory image, and the frame, background and shadow are drawn around it with the Canvas 2D API entirely on your device. There is no upload, no server-side rendering and no external image service — nothing about the screenshot leaves your browser.
The Device Mockup Generator is 100% client-side. When you drop or choose a file it is decoded locally as a same-origin data URL into an HTMLImageElement; the device frame, the notch or browser chrome, the laptop base or monitor stand, the background gradient and the drop-shadow are all painted on an HTML5 <canvas>, and the final PNG is produced by canvas.toBlob() on your machine. Because the image is a same-origin data URL, the canvas is never “tainted”, so export always succeeds without a server. There is no upload endpoint, no cloud rendering and no external stock-photo or AI relighting in the path — the only network use on the page is the site’s ads. The tool works offline once cached and discards everything when you close the tab.
Cover scales your screenshot to completely fill the device screen and crops whatever overflows — best when the screenshot roughly matches the screen’s shape. Contain scales it to fit entirely inside the screen without cropping, letterboxing any leftover space on the screen’s dark backdrop.
The two options mirror CSS object-fit. Cover fills the screen edge-to-edge and trims the parts of the screenshot that don’t fit the screen’s aspect ratio — you get a clean full-bleed screen, at the cost of some cropping if the ratios differ, which you can nudge with the Pan X / Pan Y and Zoom sliders. Contain fits the whole screenshot inside the screen so nothing is cropped; if the ratios differ you’ll see letterbox bands (which sit on the screen’s dark “off” colour). For a pixel-perfect result with neither cropping nor letterboxing, capture your screenshot at the frame’s native aspect ratio (e.g. a tall ~19.5:9 capture for the modern phone, 4:3 for the tablet).
Export at 1× for quick on-screen use, 2× for Retina / high-DPI displays and most web heroes, and 3× for print or very large placements. The scene is re-rendered at the larger size so it stays sharp; larger sizes just use more of your device’s memory.
The preview renders at a base frame width (~900px), and export multiplies that by your chosen scale, re-running the whole composite so the frame edges, rounded corners and screenshot stay crisp rather than being upscaled. Because a PNG is a fixed-resolution raster, pick a size comfortably above where you’ll use it: 1× is fine for a thumbnail or slide, 2× is the safe default for websites and Retina screens, and 3× suits print or hero banners. Transparent backgrounds export as true PNG transparency so the mockup drops cleanly onto any page. All rendering is local, so extremely large exports are bounded only by your device’s available memory.
No. They are stylised, logo-free frames — clean generic representations of a phone, tablet, laptop, monitor, browser and watch with realistic proportions, notches and stands, but not pixel-perfect renders of any specific branded product, and they carry no trademarks.
To keep the tool self-contained and free of trademark issues, the frames are hand-defined generic devices rather than exact replicas of any brand’s hardware. They use realistic proportions and details — a notch or punch-hole and a home-indicator on the modern phones, a camera dot and bezel on the tablet and laptop, a keyboard base or monitor stand, a browser toolbar with traffic-light dots — so a screenshot reads clearly as “on a device”, but there are no logos and the shapes are not certified matches for a particular model. This is deliberate: it means the whole library ships as inline canvas geometry with no external device images to download, which is what keeps everything private and offline.
Detailed Explanation
📖How It Works
What the Device Mockup Generator Does
The Device Mockup Generator places a screenshot inside a stylised, logo-free device frame — a phone (notch, punch-hole or classic bezels), a tablet, a clamshell laptop, a desktop monitor, a browser window, or a smart watch — so an app or website reads as “on a real device” for stores, landing pages and portfolios. The user drops a screenshot, picks a device, finish and orientation, adds a local background, shadow and padding, pans/zooms the image, and exports a PNG. Everything is composited in the browser with no upload.
Eight logo-free frames across phone, tablet, laptop, monitor, browser and watch
Live WYSIWYG preview at the frame’s true aspect ratio
Local gradient / solid / transparent backgrounds — no external stock imagery
PNG export at 1×, 2× or 3× for screen, Retina or print
The screenshot is read locally and never uploaded
⚙️Methodology
Normalised Geometry + Object-Fit Compositing
A pure engine (deviceMockupEngine.ts) stores each device as NORMALISED coordinates: the screen rectangle is expressed as fractions (0–1) of the frame box, so one scale factor maps the whole thing to any export resolution while keeping bezels, corner radii and notches proportional. Landscape rotates the normalised rectangle. The screenshot is fitted to the screen with object-fit semantics — “cover” samples a crop that fills the screen, “contain” fits the whole image and letterboxes — with an added user zoom and pan window, all computed as pure functions.
Device screens defined as 0–1 fractions of the frame box
One scale factor drives preview and every export size
Cover = sample a filling crop; Contain = fit whole + letterbox
User zoom shrinks the sample window; pan shifts it within the overflow
Landscape swaps the frame aspect and rotates the screen rectangle
🔧Technical Details
Canvas Compositing and PNG Export
The frame body and lighter edge, the screen “off” backdrop, the notch or punch-hole, the home-indicator, the browser toolbar with traffic-light dots and URL pill, the laptop base or monitor stand, a background gradient (a canvas linear gradient whose angle matches CSS linear-gradient) and a soft drop-shadow are all painted with the Canvas 2D API; the screenshot is clipped to the screen’s rounded corners. Export re-renders the entire scene onto an offscreen canvas at 1×/2×/3× the base width and reads it back with canvas.toBlob(), so edges stay crisp rather than upscaled.
Whole scene (frame, notch, stand, chrome, background, shadow) drawn on canvas
Screenshot clipped to rounded screen corners via a rounded-rect path
CSS-matched gradient angle converted to a canvas linear gradient
Export re-renders at 1×/2×/3× then canvas.toBlob() → downloadable PNG
Same-origin data-URL image keeps the canvas untainted so export never fails
📋Use Cases
When to Use Cover vs Contain, and Which Frame
Use Cover for a full-bleed screen when the screenshot roughly matches the device shape; nudge the crop with Pan and Zoom. Use Contain when nothing may be cropped — leftover space letterboxes on the screen’s dark backdrop. For a pixel-perfect fit, capture at the frame’s native ratio (~19.5:9 for the modern phone, 4:3 for the tablet, wide for laptop/monitor/browser). Templates (App Store hero, Landing hero, Browser demo, Tablet showcase, Transparent PNG, Desktop mockup) give sensible starting points.
Cover fills and crops; Contain fits and letterboxes
Match the screenshot’s aspect ratio to the frame to avoid both
Pan / Zoom fine-tune the crop under Cover or Zoom > 1
Six templates cover common store / marketing scenarios
Transparent background exports a PNG that drops onto any page
⚠️Limitations
Honest Limitations
The frames are stylised and logo-free — clean generic representations with realistic proportions, notches and stands, not pixel-perfect renders of any specific branded product, and carrying no trademarks. Cover crops to the screen’s aspect ratio; a very different screenshot ratio won’t match one-to-one. Output is a fixed-resolution PNG raster (no SVG/vector), so export at 2×/3× for print or high-DPI. There is no 3-D perspective, tilt, reflection or AI relighting — it is a clean flat mockup by design — and very large export sizes depend on the device’s available memory.
Stylised, logo-free frames — not exact replicas of any brand’s hardware
Cover can crop; capture at the native ratio for a one-to-one fit
PNG raster only (no SVG); export 2×/3× for print / Retina
No 3-D perspective, tilt, reflection or AI relighting
Local rendering — huge exports are bounded by device memory
🔒Privacy & Security
Private by Design
Everything happens on the user’s device. The screenshot is read with the FileReader API into an in-memory image (a same-origin data URL), composited on an HTML5 canvas locally, and exported with canvas.toBlob() — there is no upload endpoint, no server-side rendering and no external stock-image or AI service in the path. The device frames are inline canvas geometry, so even they trigger no download. The tool works offline once cached, keeps no accounts and sets no tracking, and discards the screenshot the moment the tab is closed.
Screenshot decoded locally as a same-origin data URL
No upload, no server-side rendering, no stock-image or AI service
Device frames are inline canvas geometry — no external images
Untainted canvas → export always succeeds without a server
Works offline once cached; no accounts, no tracking; discarded on close
Cover vs. Contain screenshot fit in the Device Mockup Generator
Aspect
Cover
Contain
Behaviour
Fills the screen edge-to-edge
Fits the whole image inside
Cropping
Crops overflow to match screen ratio
No cropping
Leftover space
None
Letterbox on the screen’s dark backdrop
Best for
Screenshots near the device ratio
Screenshots that must show fully
Fine-tuning
Pan X/Y + Zoom to reframe the crop
Zoom to scale within the screen
One-to-one fit
Capture at the frame’s native ratio
Capture at the frame’s native ratio
Both are computed on your device with object-fit semantics; the screenshot is never uploaded. As of July 2026.