Restpack Alternative: Screenshot API Comparison for Developers

Most developers looking for a restpack alternative hit the same friction points: no permanent free tier, basic stuff like ad blocking and retina locked behind expensive plans, and only three output formats in 2026. The product still works, but the pace of new features has dropped off since the 2021 acquisition. I built screenshotrun, so take this comparison with that context. Every claim below is checkable against both APIs' public docs and pricing pages.

This screenshot API comparison covers features, pricing, and what you actually get at each tier in this restpack vs screenshotrun breakdown.

What each API ships on day one

The basics overlap: full-page screenshots, HTML input, CSS injection, viewport control. Where the two APIs split is what you can actually use at each price point. The restpack screenshot API reserves some of the most common needs for higher-tier plans. More on that below.

The $9.95 plan isn't what it looks like

Restpack's cheapest plan, Developer at $9.95/month, covers 1,000 screenshots with the core API. Sounds reasonable. But check what's missing from that tier: no ad blocking, no cookie banner removal, no retina output. Those features start at the Startup plan ($39.95/month) for ads and cookies, and the Business plan ($99.95/month) for retina.

So you sign up for $9.95, start testing, and the screenshots come back with consent popups covering half the page and ads breaking the layout. To get clean, sharp captures you'd actually use in production, you're looking at $39.95 minimum. At that price, screenshotrun's $29 plan already includes 15,000 screenshots with every feature available.

screenshotrun doesn't split features across plans. The free tier and the $99 plan have the same capabilities: dark mode, ad blocking, retina, stealth mode, webhooks. The only difference between plans is the number of screenshots per month.

This is the main reason developers look for a restpack alternative in the first place. The API itself is fine — it captures pages, handles basic parameters, returns images. But the moment you need a clean screenshot without popups and ads, you're paying three to four times more than the entry price suggested.

Output formats: three vs six

Restpack outputs PNG, JPEG, and PDF. In 2026, WebP and AVIF aren't niche formats anymore. WebP typically cuts file size by 25-40% compared to PNG at the same visual quality. AVIF pushes that even further.

screenshotrun supports PNG, JPEG, WebP, AVIF, TIFF, and PDF. If you're generating thousands of thumbnails or embedding screenshots in web pages, picking the right format can make a real difference in page load times and storage costs. Restpack doesn't give you that choice.

For context, we tested the same 50 URLs through both APIs. Restpack returned PNG and JPEG files averaging 1.2 MB each. screenshotrun returned WebP versions of the same pages at around 400-500 KB — less than half the size, same visual quality. At 10,000 screenshots per month, that format choice alone can save 7-8 GB of storage and CDN bandwidth.

Three APIs vs one endpoint

Restpack runs screenshots and HTML-to-PDF as completely separate products. Each has its own dashboard, its own billing, and its own API key. If a project needs both screenshots and PDF generation, you're managing two subscriptions and two integrations.

screenshotrun handles this with a single parameter. Change format=png to format=pdf in the same API call and you get a PDF instead of an image. Same endpoint, same key, same billing. One less vendor to manage.

Restpack also has a Browser Mockup API that wraps any image in a browser chrome frame. That's useful for marketing materials and app store listings. screenshotrun doesn't have this. If browser mockups are a regular part of the workflow, that's a genuine advantage for Restpack.

HTML and Markdown input

Both APIs accept raw HTML as input — you send markup instead of a URL, and the API renders it and takes a screenshot. Restpack supports this through its html parameter, which works well for generating images from templates.

screenshotrun goes a step further with Markdown input. Pass a Markdown string directly and get a styled image back. This is useful for generating social cards from blog posts, rendering changelogs as images for Slack or Discord, or creating documentation screenshots from content that already lives in your repo. No hosting step, no public URL needed — just the raw Markdown text in the API call.

If your workflow involves turning text content into images regularly, the Markdown option saves a build step. With Restpack, you'd need to convert Markdown to HTML first, host it somewhere, and then point the screenshot API at that URL. With screenshotrun, it's one API call.

Restpack pricing vs screenshotrun

Per-screenshot cost at the entry tier works out to $0.003 on screenshotrun versus $0.01 on Restpack. That's more than three times the unit cost. At higher tiers, the gap narrows but screenshotrun stays cheaper at every level.

Pricing alone only tells half the story, though. At $9.95 on Restpack, you don't have ad blocking or retina. To get those, jump to $39.95. At that price point, screenshotrun's $29 plan gives you more screenshots with every feature included. Honestly, I'd always pick the plan where everything works out of the box over one where I have to upgrade just to get clean screenshots.

Anyone doing a proper restpack review will notice this gap quickly. The pricing page looks competitive until you map features to tiers, and then the real cost of production-quality screenshots becomes clear.

Selector wait vs fixed delay

Both APIs support waiting for a CSS selector before capturing. Restpack uses a shutter parameter that watches for a selector with a hard 10-second timeout. screenshotrun's wait-for-selector works similarly but with a configurable timeout that matches your overall request timeout.

The difference shows up on slower pages. If an element takes 12 seconds to load, Restpack's shutter gives up at 10 and captures whatever's on screen. screenshotrun waits as long as needed (within the request timeout you set). On SPAs and pages with heavy JavaScript, that extra flexibility means fewer incomplete captures.

This matters more than it sounds. If you're capturing dashboards, e-commerce pages with product carousels, or anything that loads data from an API after the initial page render, a fixed 10-second cap will eventually bite you. We've seen pages where a chart component loads in 8 seconds on a fast connection and 14 seconds under load. With a fixed shutter, those late-loading captures come back missing the one element you actually needed.

screenshotrun also supports click_selector — click a button or close a modal before the screenshot is taken. Pair that with wait-for-selector and you can handle multi-step page states: wait for a chart to load, click a tab to switch views, wait for the new content to render, then capture. Restpack doesn't have click support, so you'd need to inject custom JavaScript to simulate clicks, and even then the timing isn't guaranteed.

What Restpack still does well

Restpack isn't a bad product. It's been on the market for about ten years, and there are things it does that screenshotrun doesn't:

• Browser Mockup API wraps any image in a browser frame. It's a separate product with its own pricing, but for marketing teams building landing page visuals, it saves building this in-house.
• Dedicated HTML-to-PDF product. If PDF generation is the only job and screenshots aren't needed, paying for just the PDF product keeps things simple.
• Long track record. The API has been live since roughly 2016. For teams where vendor stability matters, a decade of operation counts for something.
• Official SDKs for seven languages: Java, C#, PHP, Python, Ruby, Go, and Node.js under Restpack's GitHub org. Worth noting that most of these repos haven't been updated since 2022-2023, so check compatibility with your stack. screenshotrun provides integration guides and code examples for the same languages but doesn't maintain standalone SDK packages.

Moving from Restpack

If you're on Restpack and thinking about switching, the migration is straightforward. Both APIs take a URL and return an image. The main differences: Restpack passes tokens as a query parameter (or header), screenshotrun uses Authorization: Bearer headers only. Swap the endpoint URL and the auth method, and most integrations work with minimal changes.

One thing worth flagging about authentication: Restpack's default approach puts your API token in the URL as a query parameter. That means your key can show up in server logs, CDN caches, and referrer headers. It's not a deal-breaker — they support header-based auth too — but the docs show the query parameter method first, and most developers copy the first example they see. screenshotrun only supports Authorization: Bearer headers, so the key never touches the URL.

Start with the free tier — 200 screenshots per month, no credit card, no 7-day countdown. Run the same URLs you're capturing with Restpack and compare the output side by side. Pay attention to how each API handles pages with cookie banners, lazy-loaded images, and dynamic JavaScript content. Those edge cases are where the differences actually surface.

For a broader look at what's available, the best screenshot API roundup covers the full market. If you're also evaluating APIs that bundle content extraction, the CaptureKit comparison covers that angle. And if you're weighing a managed API against running your own browser, the Puppeteer vs screenshot API guide breaks down the tradeoffs.

The restpack alternative that doesn't gate features

screenshotrun costs less at every tier, gives you three times more screenshots on the entry plan, and includes every feature from day one. No upgrades needed for ad blocking, retina, or dark mode. One API key covers both screenshots and PDFs. If clean captures with full control matter more than browser mockups, it's the simpler choice.