Build1 distinct publisher3 min readPublished
The costs came from Apify's own accounting rather than an estimate, and correcting one memory field moved the measured spread from 96x down to 33x. Requests per row still explains everything left.
The Engineer · Build desk

Follow any of these and your For You feed starts watching them — no settings page required.
build
One bookkeeping row turns an empty scrape into a billable event1 distinct publisher
build
Apify's store search excludes Actors until their publisher clears identity verification1 distinct publisher
product
The AI coding bill stopped counting seats, and the number leadership wants isn't in any console1 distinct publisher
build
An Apify Actor now falsifies its own DNS results before the agent reads them1 distinct publisher
Compiled by The EngineerSomething wrong?How this is made
Apify bills memory multiplied by time, so a container held open at 4096 MB costs eight times per second what the same code costs at 512 MB, whether or not anything uses the headroom [8]. The four Actors in question have no browser and no Playwright, one dependency, plain `fetch`, and detail lookups that run in a sequential rate-limited loop [9]. The author's summary is "four gigabytes to hold one HTTP response at a time" [9]. 4096 divided by 512 is 8, and that multiplier lands on the whole wall clock, not on some peak the heap never reaches [20].
The re-run closes it from both ends. Cost moved roughly linearly with the memory setting while time stayed flat [11], and on a real workload of 51 rows in 108 seconds throughput was identical across settings [12].
What has to be true for that to transfer: your working set has to actually fit in 512 MB. Nothing here measures a browser-based Actor, so the finding is scoped to browserless fetch loops, which is exactly what these four are [9]. If your Actor drives Chromium, the 8x is still the billing rule, but the flat-in-time result is untested.
The spread was reported as 96x across $0.008 to $0.730 [3]; after the memory fix it is 33x [13]. That means one config field inflated the apparent spread by a factor of about 2.9 [21]. Note also that 0.730 divided by 0.008 is 91.25, not 96 [22], so the headline multiple came from figures behind the rounded table rather than from the table itself.
Defaults did not drive the cost here; architecture did. Requests per row remains the largest architectural driver and accounts for the entire 33x that survives the fix [14]. What the memory setting corrupted was the ranking: four Actors sat at the top for a reason that had nothing to do with their code, and the first draft explained their position with a well-supported argument about their code [19]. The author's own framing is the useful one, that a derived number hands you a value and a ranking, and a misconfigured input gives you a confidently wrong ranking rather than a slightly wrong value [18]. The ranking is the part you reason about.
Which is where per-event pricing comes in. Eleven Actors had prices named per unit of value before anyone knew what a unit cost to produce [17]. Two things make that hard to fix after the fact. On the free plan, runs and their datasets are kept for a limited window and then removed, and figures from two weeks earlier were simply gone [15]. And a single run is not a measurement, because per-run overhead lands entirely on however many rows that run happened to produce [16].
One field is the fix, not eleven separate edits. The 4096 value is the kind that lands in a scaffold template and then in every Actor built from it, and the author has no memory of choosing it [10]. So the memory field belongs in the same review as the price, and the template is where you set it.
Ranked by verification strength, evidence, and original report placement.
The author measured 22 runs across every Actor they have published, 11 in total, taking cost from the platform's own accounting rather than from an estimate.
Every finished Apify run carries usageTotalUsd and every dataset carries itemCount; cost per row is the first divided by the second, multiplied by 1000 for a per-thousand figure.
The measured costs ranged from $0.008 to $0.730, described by the author as a 96x spread.
In the first measurement, the most expensive Actor was the one the author gives away for free.
Cheap Actors ran at 5 to 8 rows per second and expensive ones at 0.3 to 0.7, because billing follows the time a machine is held open.
A reader of the draft asked whether the $0.730 figure was actually fine as it stood, which led the author to check the run settings of the four most expensive Actors.
Distinct publishers with included, body-backed reporting in this cluster.
1 article · September 5, 2026
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Platform-metered, one hand on the meter
This figure comes straight out of Apify's billing records through usageTotalUsd, not from an estimate, and the derivation is three lines anyone can rerun on their own account. Against that, all 22 runs sit in one seller's account, the comparison tables are described rather than printed, and the headline arithmetic is loose enough that the two published endpoints divide to 91 rather than the stated 96. The strongest part is the control: two memory settings, same input, then a 51-row workload to rule out the sample of one.
Real runs, one account
Twenty-two production runs and a publicly listed Actor whose per-thousand cost fell about fourfold are genuine usage, not a demo. But the footprint ends at northbell's own eleven Actors: nobody else selling on Apify has reported memory-inflated bills, nobody else has published a cost-per-row table with a memory column in it, and the platform itself has given no indication it is responding to any of this.
Deflated by its own author
The eye-catching number gets taken away by the person who produced it: 96x is retired for 33x halfway through, and the closing irony of the withdrawn draft is retracted along with it. What remains is narrower than the evidence gathered for it, and it is stated flatly. The one place the framing runs ahead of what a reader can verify is the claim that requests per row explains the entire residual spread, since the corrected table is not shown.
Written from inside the marketplace
This appears on Apify's own dev.to organisation, written by a seller whose Actors are the data set and whose free LinkedIn scraper gets a link at the end. The interests pull both ways. Admitting that four Actors were shipped at eight times the memory they needed is unflattering, and northbell never asks whether the platform's scaffold put the value there or what over-provisioning earns Apify. Meanwhile the free sample now reads as four times cheaper, which is a fine thing to have written up.
Transparent method, single provenance
Enough is shown that a sceptical reader can check the mechanism themselves: memory times time is Apify's documented billing rule, 4096 against 512 is an eightfold multiplier, and a controlled sweep plus a real workload both show throughput unchanged. What limits confidence is that the tables themselves are not shown, there is no second observer, and where the 4096 figure originated has not been confirmed.