Move the public-page slice from Urlbox.

Latchshot can replace synchronous PNG, JPEG, or PDF captures when your application can receive the artifact bytes directly. It cannot replace an Urlbox render link inside an image tag, a temporary hosted render URL, provider caching, async delivery, page modification, or storage.

Provider migration reference · Public-page boundary · Updated July 19, 2026

Start with the response contract

Move the capture only when your server owns delivery.

Urlbox supports several surrounding workflows: signed render links, JSON responses with a temporary renderUrl, async jobs, webhooks, caching, and cloud storage. Latchshot has a smaller contract. An authenticated server request returns the image or PDF bytes synchronously, and your application decides whether and where to store them.

Good migration candidate

Your backend needs one artifact now.

Input
A public HTTP or HTTPS page on port 80 or 443
Controls
Viewport, scale, full page, wait strategy, short delay, dark mode, and output format
Output
PNG, JPEG, or PDF bytes returned to an authenticated server call

Keep Urlbox

The URL or workflow is part of the product.

Embedding
A signed render link appears directly in HTML, email, or social metadata
Delivery
A temporary hosted URL, async status, webhook, cache, or cloud upload is required
Browser work
Selectors, clicks, custom/exhaustive blockers, cookies, headers, scripts, proxies, or private content are required
Not affiliated with Urlbox.

Urlbox is a product of its respective owner. This page is a migration reference for the smaller Latchshot contract. Confirm the current Urlbox options, JSON API, and render-link behavior used by your application.

Keep Bearer authentication; change what comes back.

Urlbox's current JSON API and Latchshot both accept a server-side Bearer credential. The important difference is the response. Urlbox POST /v1/render/sync returns JSON containing a temporary hosted renderUrl. Latchshot POST /v1/render returns the artifact bytes directly.

Before: Urlbox JSON API

curlBearer secret → temporary render URL
curl -fsS \
  'https://api.urlbox.com/v1/render/sync' \
  -H "Authorization: Bearer $URLBOX_SECRET" \
  -H 'Content-Type: application/json' \
  -d '{
    "url": "https://example.com",
    "format": "png",
    "width": 1440,
    "height": 900,
    "full_page": false
  }'

# {"renderUrl":"https://renders.urlbox.com/…png", ...}

After: Latchshot binary response

curlBearer key → PNG bytes
curl -fSL \
  'https://latchshot.fly.dev/v1/render' \
  -H "Authorization: Bearer $LATCHSHOT_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "url": "https://example.com",
    "kind": "screenshot",
    "format": "png",
    "width": 1440,
    "height": 900,
    "fullPage": false
  }' \
  -o after.png
Signed render links need an architecture change.

An Urlbox link can sit in an <img src> because its key and HMAC token are encoded in the path. Latchshot never accepts a credential in the URL. Call it from a trusted server with the Bearer header, then serve the stored bytes or an application-owned URL.

Translate the controls with exact semantics.

Start from the smallest request. Several names map directly, but wait behavior and output delivery do not. Compare representative pages instead of assuming similar names produce identical pixels.

Urlbox conceptLatchshotMigration note
Authorization: Bearer …Authorization: Bearer …Replace the provider secret with a Latchshot key; keep both outside client code and logs.
HMAC render-link tokenNo URL credentialMove capture to a trusted server call. There is no direct-image-link equivalent.
urlurlInclude http:// or https://; Latchshot does not prepend a scheme.
widthwidthLatchshot accepts 320–2560 pixels.
heightheightLatchshot accepts 240–1440 pixels.
retina=truescale=2Use scale 1 or 2; confirm resulting pixel dimensions and storage.
format=pngkind=screenshot, format=pngBinary PNG response.
format=jpeg/jpgkind=screenshot, format=jpegLatchshot uses the value jpeg.
qualityqualityJPEG only; use an integer from 1–100. Latchshot defaults to 85.
format=pdfkind=pdfA4, Letter, and Legal map to paper; landscape maps to landscape=true.
full_pagefullPageBoolean; validate tall pages and artifact size before cutover.
delaydelayBoth use milliseconds. Latchshot caps the delay at 3000 ms.
timeouttimeoutBoth use milliseconds, but Latchshot accepts 3000–30000 ms rather than Urlbox's documented 5000–100000 ms.
wait_until=loadedwaitUntil=loadEquivalent event name.
wait_until=domloadedwaitUntil=domcontentloadedEquivalent DOM event name.
requestsfinishednetworkidleClosest available choice, not an identical network-idle definition; retest dynamic pages.
mostrequestsfinishedNo exact equivalentDo not silently translate the two-connection threshold.
dark_modedarkModeBoolean media preference.
reduced_motionreducedMotionBoolean; Latchshot defaults to reduced motion for stable output.
Ad blockingblockAdsBest-effort blocking of requests to known third-party ad hosts; validate any required custom filter behavior.
Tracker blockingblockTrackersBest-effort blocking of known third-party analytics and tracker hosts.
Cookie-banner handlinghideCookieBannersHides common consent overlays without clicking consent or setting consent cookies.
thumb_width, thumb_heightNo independent resizeCapture at the required viewport or resize the returned artifact downstream.
renderUrl or render linkBinary responseStore and serve the bytes in your application if a durable URL is required.

On a narrow screen, scroll the option table horizontally.

Stop if Urlbox supplies more than rendering.

Latchshot has no equivalent for these Urlbox capabilities. Removing one can change the page, response, delivery contract, or security model.

  • Direct embedding and hosting: render links, temporary renderUrl responses, provider caching, ttl, force, deduplication, and hosted refresh behavior.
  • Async and storage: async renders, status polling, webhooks, S3-compatible uploads, custom CDN hosts, and provider-managed storage.
  • Page changes: selectors, clicks, hover, cleanup beyond the five best-effort controls, injected CSS or JavaScript, raw HTML input, headers, cookies, and custom user agents.
  • Network placement: custom or managed proxies, geolocation, time-zone placement, authenticated pages, private hosts, and non-standard target ports.
  • Image and PDF processing: thumbnail resizing, clipping, padding, background changes, page ranges, custom PDF dimensions, headers, footers, metadata, and arbitrary PDF scale.
  • Other outputs and analysis: WebP, AVIF, SVG, HTML, Markdown, video, metadata extraction, readable content, LLM output, and certified renders.

Keep Urlbox for any job that needs those features. A split-provider design is safer than weakening an existing workflow to force a migration.

Fit first. Implementation if it fits.

The fit check is free. Review the exact $99 pilot scope and acceptance boundary, then open a public migration-fit question on GitHub with the request contract, required provider behavior, and expected volume. For one eligible JavaScript/TypeScript or Python backend call site in a public GitHub repository you control, choose the optional $99 implementation pilot. API usage is separate. Never include a key, private or signed URL, customer data, or sensitive artifact.

Cut over one eligible job at a time.

  1. Inventory the exact Urlbox request shape, including delivery, storage, cache, and page-modification options.
  2. Reject any job that depends on the stop list. Do not treat an <img src> render link as a server API call.
  3. Render a representative public-page set through both providers using fixed viewports and formats.
  4. Compare dimensions, visible content, fonts, navigation completion, latency, and the surrounding storage or delivery behavior.
  5. Route a bounded share of eligible jobs to Latchshot and keep the Urlbox path until rollback has been exercised.

Retry only 429, 502, 503, and 504, with a strict attempt cap. Treat authentication, validation, and target-policy failures as permanent until the request changes.

Price the complete workflow.

Latchshot counts successful direct renders. Failed direct renders do not consume monthly quota, and automatic overages are disabled during the beta. The current plans are Free at 100 successful renders each UTC month, Launch at $19 for 2,500, Build at $49 for 12,000, and Scale at $149 for 50,000.

That is not proof that migration is cheaper. Include downstream image resizing, object storage, transfer, URL delivery, retry volume, engineering work, and every Urlbox-only job that remains.

Use the Free plan for a comparison sample.

The reference run completed 197 of 200 preflighted public HTML roots at 2.42-second p50 and 7.68-second p95 end to end. It is engineering evidence, not an SLA or a prediction for your pages.

Create one Free-plan key, save it when it is returned, and use the 100 monthly successful renders on a representative eligible set.

Test the smaller contract.

Move only synchronous public-page captures whose caller can receive bytes. Keep Urlbox wherever its link, hosting, modification, storage, or delivery features are part of the job.

Get a free key