Engineering time is hidden
Browser upgrades, failed deploys and incident response are labor. Setting the input to zero is valid only when that work is genuinely absorbed by an already-owned platform.
Web capture engineering
Build vs buy a screenshot API: an editable calculator
Comparisons often price one browser invocation against one API credit and omit the actual ownership boundary: upgrades, failed jobs, queueing, security, observability and on-call time.
4 min readPublished Updated
What you actually see
A confident annual-savings number whose result changes completely when one hidden engineering-hours assumption is made visible.
Reproduce it
- 01Write every assumption in units: requests, cache-hit rate, failure rate, browser minutes, compute price and engineering hours.
- 02Calculate billable API successes separately from raw requests; PageCapture does not charge failures or cache hits.
- 03Set engineering time to zero and API cache hits to zero as a sensitivity check. If the conclusion flips, report the range rather than one headline number.
The DIY version
Start with the smallest thing that works
A transparent comparison is a small formula. Keep inputs editable and show annual totals without declaring either result universally cheaper.
build-vs-buy.ts
const months = 12;
const browserAttempts = Math.ceil(
requestsPerMonth * (1 - cacheHitPercent / 100)
);
const billableApiRuns = Math.ceil(
browserAttempts * (1 - failurePercent / 100)
);
const diyAnnual = months * (
browserAttempts * browserMinutesPerRun * computePerMinute
+ storageAndEgressPerMonth
+ engineeringHoursPerMonth * loadedHourlyRate
);
const apiAnnual = months * (
apiSubscriptionPerMonth
+ apiOveragePerThousand * Math.ceil(Math.max(0, billableApiRuns - includedCredits) / 1000)
);
console.table({ billableApiRuns, diyAnnual, apiAnnual });Where it breaks
The call is small. Everything around it is the system.
Raw traffic is treated as billable
A cached repeat or failed capture consumes no PageCapture credit. Compare billable successful renders, not page views or caller retries.
Requirements are assumed equivalent
An API does not replace unrestricted CDP, multi-browser tests or a human-driven login. A lower number is irrelevant if the workload does not fit the contract.
Risk is converted into fake precision
Do not monetize an outage with an invented universal rate. Show operational boundaries separately and let the team apply its own risk tolerance.
Keep the DIY version when
- The browser is core infrastructure with dedicated owners and this workload adds negligible marginal complexity.
- The job needs capabilities outside the API contract, so the decision is build regardless of the nominal calculation.
What you get, and what it costs
Output, limits, cost, failures
Output
An editable annual comparison with every monetary and workload assumption visible, plus the billable API run count used in the calculation.
Cost
One successful, non-cached capture costs one credit. Failures, including platform failures, cost zero; cache hits cost zero.
1 creditper successful non-cached capture
Limits
- Default values are an example scenario, not a benchmark or promise.
- The calculator excludes taxes, discounts, outage-loss estimates and currency conversion.
- Overage rounds up in blocks of 1,000 exactly as the product billing contract does.
Common errors
request_not_validnever billed
The representative workload needs an option or interaction outside the public contract.
HTTP 400 · terminal
screenshots_limit_reachednever billed
Successful non-cached volume exceeds included credits and the configured hard limit.
HTTP 400 · terminal
Editable model
Put your assumptions in the open
These defaults are an example scenario, not a benchmark. Change every workload and price input. The model counts cache hits as free on both sides, charges DIY compute for failed attempts, and charges API credits only for successful non-cached captures.
Browser attempts
16,000
Billable API captures
15,680
Overage blocks
6
Operate it yourself
$837.00/ month
- Browser compute
- $12.00
- Storage and egress
- $25.00
- Engineering and on-call
- $800.00
- Annual total
- $10,044.00
Use the API
$68.00/ month
- Subscription
- $47.00
- Rounded overage
- $21.00
- Annual total
- $816.00
With these assumptions, the API model is lower by $769.00 per month. The break-even allowance is 0.31 engineering hours/month.
Excludes taxes, discounts, incident losses and currency conversion. Cost does not decide capability fit: keep DIY when the browser is core infrastructure or the API contract cannot express the job.
Try it against your own page
The runner above carries this exact configuration into the playground — no retyping, no starting over.
Tested and reviewed
Written by PageCapture Engineering. Reviewed by PageCapture product and billing maintainers. Verified 2026-08-12 by running the published code against a fixture.
Calculator arithmetic is unit-tested against plan prices, success-only billing, free cache hits and 1,000-credit overage rounding; the representative recipe is normalized and syntax-checked.
engine-crunknown-pwunknown-f2026-07-1-b2026-07-1StatusRepresentative capture referenceEditorial method
Sources and verification basis
Sources support the browser and API behaviors named above. PageCapture-specific limits and billing are taken from the public contract; external sources are used for the underlying browser behavior.
- PricingPageCapture
Provides the contractual subscription, credit and overage inputs.
- CachingPageCapture
Defines which repeated captures are free and how cache identity works.
- Playwright browsersPlaywright
Defines the browser installation responsibility retained by DIY deployments.
Adjacent pages
Contractual pricing
Replace example API inputs with the current published plan.
Serverless operating boundary
Estimate the deployment responsibilities behind engineering hours.
Queue ownership
Decide whether retry and idempotency are marginal or new platform work.
Cache identity
Estimate billable runs from real repeat behavior.