fal

fal.ai · Compute, Storage · 4 records · JSON

fal Research Grants Computecaveatemailno cardDwrite-gated
fal Computepaidemail?card?Dwrite-gated
fal.ai Storagefails: quotaemail?card?R
fal.ai persistent /data volume Storagefails: quotaemail?card?Rper-object-cap

fal Research Grants Compute

caveatemailno cardDwrite-gated

fal.ai/grants · GPU cloud · compute/fal-research-grants · JSON · compare

Free tier	Free compute on fal's inference platform. The eligibility sentence is the most open found in this class, quoted: 'The fal Research Grants program is open to anyone passionate about advancing AI through open source projects. No formal degree is required - your ideas and dedication are what matter most.' The amount is not published anywhere on the page. The route is an email to grants@fal.ai with a project description, goals, and 'any relevant work or GitHub repositories'. unit none; metered on wall-clock; one-time-credit
Price	none stated
Per-object cap	not applicable
Retention	not applicable
Egress	not stated
Identity	email not published
Limits	write-gated the award has no published amount, cap, duration or expiry, so the only thing bounding it is a discretionary reply to an email. source the award has no published amount, cap, duration or expiry, so the only thing bounding it is a discretionary reply to an email.
Binding	write-gated the award has no published amount, cap, duration or expiry, so the only thing bounding it is a discretionary reply to an email.
Interface	unknown inferred from the tooling the provider documents; not probed
Tooling	not stated
Composes with	The grant is platform credit, so it composes only with fal's own models; it is a supplement for an inference-heavy step, not a training allowance.
Reliability	no reliability event recorded
Notes	Recorded for the door rather than the number, and it is honest to say so: no figure exists on the page, so the finding cannot rank against Lambda or TRC. What makes it worth a line is the explicit removal of the degree requirement in a class where nearly every other program gates on it, plus the fact that the application is an email rather than a form. The named testimonials are the only proof it pays out. Whether the credits are GPU-seconds on fal's inference endpoints or spend on the platform is not stated, and that distinction decides whether a training run is possible at all - it probably is not, which is the caveat.
Evidence rung	documented
Checked	2026-10-22 (live); stale on 2026-11-21

Evidence (2)

date	source	what it proved
2026-10-22	fal.ai/grants	'open to anyone passionate about advancing AI through open source projects'; No formal degree is required'; 'simply reach out to us at grants@fal.ai'; quoted; page 200
2026-10-22	fal.ai/grants	the page publishes no amount, no duration and no expiry; the only evidence of awards is two named testimonials (Vik Korrapati for Moondream, Peng Zheng for BiRefNet), which show the program paid out to identifiable people but carry no figure

More fields (1)

{
 "wave2": {
  "class": "research-credit",
  "free_tier_kind": "one-time-credit",
  "shape": {
   "vcpu": null,
   "ram_gib": null,
   "gpu_class": null,
   "gpu_count": null
  }
 }
}

Unknown or withheld values (10)

$.egress.metered egress-unknown
$.egress.terms not-stated
$.identity_cost.detail process
$.interface interface-unknown
$.per_object_cap.notes process
$.per_object_cap.stated not-applicable
$.reliability_note none-observed
$.retention.notes process
$.retention.stated not-applicable
$.tooling not-stated

fal Compute

paidemail?card?Dwrite-gated

fal.ai/pricing · GPU cloud · compute/fal · JSON · compare

Free tier	not published unit none; metered on wall-clock
Price	none stated
Per-object cap	not stated
Retention	not stated
Egress	not stated
Identity	email (placeholder) not published
Limits	request-rate per-second and per-token model rates, from $0.007 per 1,000 tokens to $1.20 per million tokens on the rows shown source write-gated no machine to rent and no free tier: the product answers model calls, so capacity is per request source excluded as gpu-only
Binding	write-gated
Interface	unknown
Tooling	not stated
Composes with	not stated
Reliability	no reliability event recorded
Evidence rung	documented the pricing page was read on 2026-10-22 and carries per-second and per-token model rates. There is no free tier and no machine to rent, so the verdict moves to paid-only on the correct grounds: this is an inference API, not compute
Checked	2026-10-23 (live); stale on 2026-11-22
Parsed numbers	`$.limits[0].value` limit:request-rate 1000.0 tokens

Evidence (2)

date	source	what it proved
2026-10-02	fal.ai/pricing	not published
2026-10-22	fal.ai/pricing	the pricing page was read on 2026-10-22 and is a model price table: 'FLUX 3 Max, seconds, $0.085, $0.425' and similar per-second and per-token rates. It prices inference, not machines, and states no free tier

More fields (12)

{
 "talaria_m10h_usd": null,
 "talaria_m24h_usd": null,
 "nemo_m10h_usd": null,
 "keep_rate": null,
 "keep_rate_basis": "no field in the source",
 "billing_model": "unclassified",
 "shape": null,
 "session_cap": {
  "wall_clock_min": null,
  "idle_reap_s": null,
  "restart_required": false,
  "note": "the unit is a second of generated video or a token; there is no session"
 },
 "persistent_storage": null,
 "network_out": null,
 "price_note": null,
 "free_tier_kind": "none"
}

Unknown or withheld values (17)

$.chaining not-stated
$.egress.metered egress-unknown
$.egress.terms not-stated
$.evidence[0].proved process
$.extras.price_note process
$.free_tier.notes withheld
$.free_tier.stated process
$.identity_cost.detail defaulted
$.identity_cost.kind identity-defaulted
$.interface interface-unknown
$.interface_detail withheld
$.per_object_cap.notes process
$.per_object_cap.stated not-stated
$.reliability_note none-observed
$.retention.notes not-extracted
$.retention.stated not-stated
$.tooling not-stated

fal.ai Storage

fails: quotaemail?card?R

fal.ai/pricing · rejected-provider · storage/fal-ai · JSON · compare

Free tier	Same shape as Replicate and worse-documented for storage: the platform is per-second GPU billing for model APIs and Serverless deploys, with a 'fal CDN' for request media that is a retention unit none; metered on none
Price	none stated
Per-object cap	not recorded
Retention	not recorded
Egress	not recorded
Identity	email (placeholder) not published
Binding	none no constraint of a named kind was recorded; the verdict rests on the quota sentence rather than on a named limit
Interface	unknown
Tooling	not recorded
Composes with	not recorded
Reliability	Same shape as Replicate and worse-documented for storage: the platform is per-second GPU billing for model APIs and Serverless deploys, with a 'fal CDN' for request media that is a retention
Notes	Same shape as Replicate and worse-documented for storage: the platform is per-second GPU billing for model APIs and Serverless deploys, with a 'fal CDN' for request media that is a retention
Evidence rung	reported
Checked	2026-10-21 (inherited); stale on 2026-11-04

Evidence (2)

date	source	what it proved
2026-10-21	fal.ai/pricing	Same shape as Replicate and worse-documented for storage: the platform is per-second GPU billing for model APIs and Serverless deploys, with a 'fal CDN' for request media that is a retention
2026-10-21	docs.fal.ai/model-apis/model-endpoints/storage	cited as the basis of the rejection: Same shape as Replicate and worse-documented for storage: the platform is per-second GPU billing for model APIs and Serverless deploys, with a 'fal CDN' for request media that is a retention

More fields (1)

{
 "dead_end": {
  "failure_class": "retention",
  "why": "Same shape as Replicate and worse-documented for storage: the platform is per-second GPU billing for model APIs and Serverless deploys, with a 'fal CDN' for request media that is a retention",
  "retry_when": null,
  "first_recorded": "2026-10-21"
 }
}

Unknown or withheld values (15)

$.chaining not-recorded
$.confidence_note withheld
$.egress.terms not-recorded
$.extras.dead_end.retry_when process
$.free_tier.notes process
$.identity_cost.detail defaulted
$.identity_cost.kind identity-defaulted
$.interface interface-unknown
$.interface_detail withheld
$.limits_note process
$.per_object_cap.notes not-recorded
$.per_object_cap.stated not-recorded
$.retention.notes process
$.retention.stated not-recorded
$.tooling not-recorded

fal.ai persistent /data volume Storage

fails: quotaemail?card?Rper-object-cap

fal.ai · paas · storage/fal-ai-persistent-data-volume · JSON · compare

Free tier	No published byte quota on the /data volume — the docs state only 'Files written to /data persist between requests, across runner restarts, and across deployments' and 'Files you write there persist until you delete them. Runner shutdown does not delete these files.' Capacity is bounded only by what you pay to keep a runner alive; there is no free storage allowance and no documented ceiling. unit none; metered on stored-bytes
Price	none stated
Per-object cap	100 GB per file (100000000000 bytes)
Retention	No published byte quota on the /data volume — the docs state only 'Files written to /data persist between requests, across runner restarts, and across deployments' and 'Files you write there persist until you delete them
Egress	NOT free and NOT anonymous: '/data' files are 'not URL-accessible' — there is no public download URL, so the egress question does not arise. Bulk in/out is via `fal files` CLI or the REST storage API.
Identity	email (placeholder) not published
Limits	per-object-cap 100 GB per file source write-gated approval (request at fal source per-object-cap is upload-method-dependent (this is the useful part): `fal files upload` CLI ~100 GB per file (10 MB parts, max 10,000 parts); dashboard drag-and-drop 1 GB; upload-from-URL 5 GB and must complete in 10 minutes; POST /serverless/files/file/local/{path} ~4.5 MB per request; writes from inside a running app are exempt ('Not subject to these limits. The runner writes straight to the volume'). Retention: indefinite, self-managed. Billing: you are billed per second for every runner state except PENDING, DOCKER_PULL and TERMINATED — SETUP and IDLE are both billed, so holding storage open costs GPU-time.
Binding	per-object-cap the per-object cap sets the shard size and therefore the object count; it bounds the total more tightly than any headline quota
Interface	rest, cli rest
Tooling	`fal` Python CLI (`fal files upload/download/list/remove`), @fal-ai/client JS storage API, `fal.download_file(url, target_dir='/data/...')` in-app. Chunked at 4 MB into a global object store; parallel reads hit a distributed cache (docs claim 6-8 GB/s distributed, 10-15 GB/s local NVMe).
Composes with	Not a free-storage chain — it is a paid-compute chain. The multiplication only works if you find a machine type cheap enough that idle runner-time is under the client's willingness to pay; that is a pricing question I did not resolve, and there is no free tier for Serverless (deploys 'need access that the fal team approves for each account').
Reliability	Serverless access is gated by per-account approval (request at fal.ai/dashboard/serverless-get-started), so this is not a self-serve multiplier. Docs warn that streaming a multi-GB artifact in small chunks to /data is much slower than one bulk copy.
Notes	No published byte quota on the /data volume — the docs state only 'Files written to /data persist between requests, across runner restarts, and across deployments' and 'Files you write there persist until you delete them. Runner shutdown does not delete these files.' Capacity is bounded only by what you pay to keep a runner alive; there is no free storage allowance and no documented ceiling.
Evidence rung	reported One page read moves it to documented.
Checked	2026-10-21 (inherited); stale on 2026-11-04
Parsed numbers	`$.limits[0].value` limit:per-object-cap 100.0 GB

Evidence (3)

date	source	what it proved
2026-10-21	fal.ai/docs/documentation/development/use-persistent-storage	'Files written to /data persist between requests, across runner restarts, and across deployments'; no quota stated
2026-10-21	fal.ai/docs/documentation/development/file-storage	upload size table: CLI ~100 GB, dashboard 1 GB, from-URL 5 GB/10 min, local API ~4.5 MB
2026-10-21	fal.ai/docs/documentation/serverless/pricing	billed states table (SETUP/IDLE/RUNNING billed; PENDING/DOCKER_PULL not)

More fields (1)

{
 "dead_end": {
  "failure_class": "dead-service",
  "why": "No published byte quota on the /data volume — the docs state only 'Files written to /data persist between requests, across runner restarts, and across deployments' and 'Files you write there persist until you delete them. Runner shutdown does not delete these files.' Capacity is bounded only by what you pay to keep a runner alive; there is no free storage allowance and no documented ceiling.",
  "retry_when": null,
  "first_recorded": "2026-10-21"
 }
}

Unknown or withheld values (6)

$.extras.dead_end.retry_when process
$.free_tier.notes process
$.identity_cost.detail defaulted
$.identity_cost.kind identity-defaulted
$.per_object_cap.notes not-extracted
$.retention.notes not-extracted