# A $0 AI App? Walking Through Hugging Face Spaces, Then Finding the Three Conditions Behind “Free”

Source: Realpha Blog (blog.getrealpha.com)
Original article and charts: https://blog.getrealpha.com/en/blog/huggingface-spaces-free-ai-app-2026-10/

> In a September 11, 2026 video, Joe Maddalone built a background-remover app on Hugging Face Spaces in under ten minutes, called it from his own machine through an API, and paid nothing. This post walks through what he did in order, checks the official docs for the three conditions that make "free" work, and compares it with my own cloud GPU rental numbers: when the free quota is enough and when renting a card is the better deal. A technical learning note, not business advice.

Published: 2026-10-02
Locale: en
Tags: Hugging Face, Gradio, ZeroGPU, Cloud GPU, AI apps, Decision making

TL;DR: Hugging Face's ZeroGPU really does let you host an AI app for $0, with three conditions: an account older than 30 days, two Spaces at most, and five minutes of GPU time a day. Great for demos and occasional use; for a big batch, renting a card is far cheaper.


![Renaissance oil painting cover: inside a stone workshop, a craftsman carves at a wooden table with a single small chisel; through the window a huge public water wheel turns in the distance, and a thin stream from it reaches a small clay cup on the table, which catches only a few drops](/covers/huggingface-spaces-free-ai-app-2026-10.png)

> *With little, one gains; with much, one is confused.*<br/>
> —— Laozi, *Tao Te Ching*, Chapter 22 (Spring and Autumn period); translation mine

On September 11, 2026, Joe Maddalone posted an eight-minute video on his YouTube channel showing how to build a background-remover app on Hugging Face Spaces: about twenty lines of Python, one push, an automatic build, and then an API call from his own laptop, all for $0. I checked it against the official docs (as of 2026-10-02). The "$0" holds, with three conditions: the account must be at least 30 days old with a verified email, a free account can host at most two of these Spaces, and you get five minutes of GPU time per day. That is plenty for demos and occasional personal use. For a large batch, renting a card is much cheaper.

## The opening: the fans aren't spinning

The video opens with a photo of Doc Brown from Back to the Future. One click on "Remove BG," and a few seconds later the background is gone. Then he says his fans aren't spinning, because none of this is running on his machine.

That hit home. The PC we use for image generation sounds like a hair dryer the moment it starts, and last month I rented a cloud GPU on vast just to get through one batch. If there's a way to run AI without buying or renting a card, I want to know where its edges are.

## Step 1: create a repo

Spaces is where Hugging Face lets people host small apps; each Space is a folder that runs itself. He creates a new one and picks Gradio, which builds the upload box and buttons for you, so there's no web page to write.

## Step 2: twenty lines of code

Three packages: rembg for background removal, the inference runtime it needs, and `spaces`, which lets the app borrow a GPU. The app itself looks roughly like this:

```python
import gradio as gr
from rembg import remove
import spaces

@spaces.GPU
def process_image(input_image):
    return remove(input_image)

with gr.Blocks() as demo:
    gr.Interface(
        fn=process_image,
        inputs=[gr.Image(label="Input Image", interactive=True)],
        outputs=[gr.Image(label="Processed Image")],
        title="Image Background Remover",
    )

if __name__ == "__main__":
    demo.launch()
```

He admits his Python isn't great, and anyone can read this.

## Step 3: switch to ZeroGPU and push

Before pushing, he switches the hardware from "CPU basic" to "ZeroGPU." ZeroGPU means the platform keeps a pool of shared GPUs: your app holds none while idle, borrows one only for the seconds it's called, then hands it back. The `@spaces.GPU` decorator is how you say "this function needs a card." Per the official docs, the default is half of an RTX Pro 6000 with 48 GB of VRAM.

![Two bars, each showing one full day. The top bar, "Rent a GPU," is filled end to end, meaning the card is held all day. The bottom bar, "ZeroGPU," has only three small filled slots with the rest left empty, meaning the card is held only for the seconds when it is actually called.](/figures/zerogpu-borrow-vs-occupy-en.svg)

⚠️ One catch: the inference runtime installed in the video, onnxruntime, is the CPU-only build; the GPU build is a separate package, onnxruntime-gpu. So in this example the background removal most likely runs on the host's CPU, and the borrowed card may sit idle. I haven't tested it; if you want the GPU to do the work, swap in the GPU package.

The first launch failed because he typed `space` instead of `spaces`. He fixed it, pushed again, the platform rebuilt, and it worked.

## Step 4: call it from your own machine

The app's footer has a "Use via API" link with ready-made sample code. He writes a few lines on his own machine, sends the Doc Brown photo over, and gets the cut-out back seconds later. His verdict: under ten minutes, no GPU, no expensive hardware, $0.

## Afterward: the three conditions behind "$0"

What the video doesn't cover is the fine print. I went through Hugging Face's official docs (as of 2026-10-02) and laid it out.

Condition one: who can host. A Gradio Space that runs on compute now generally requires a paid plan to create. The one exception for free accounts is ZeroGPU, and only for accounts at least 30 days old with a verified email. That may also explain why he switched from CPU basic to ZeroGPU: under the current rules, CPU basic is the route that doesn't work for a free account. I tested that part myself (see the next paragraph). The video doesn't say whether his account is paid, though, and the rules on the day he recorded may differ from today's, so "that's why he switched" is still my inference.

I ran into this one myself. On October 2, 2026, I signed up following the steps in this post and verified my email the same day, but I can't host my own ZeroGPU app until November 1. In the meantime I can use ZeroGPU Spaces other people have built, and host my own once the 30 days are up.

The same day I also tried CPU basic: creating a Gradio app on a free account got an immediate "Payment Required" (error 402). The only route that worked was a static Space, which just serves web pages and runs nothing on the platform, and a free account can create one right away. I rewrote two small tools as plain web pages and put them up; you can try them in the [lab](/en/lab/reverse-dcf/).

Condition two: how many. A free account can host up to two ZeroGPU Spaces; a PRO account can host ten.

Condition three: how long per day. The quota is charged to whoever calls the app: two minutes a day if not logged in, five minutes for a free account, forty for PRO, resetting 24 hours after first use. Each call holds the GPU for up to 60 seconds by default. PRO users can keep going past the daily quota with pre-paid credits, at $1 per 10 minutes. Also, free Spaces fall asleep after a stretch without visitors, and the next visitor has to wait for them to wake up.

![Three horizontal bars of very different lengths: not signed in at 2 minutes, a free account at 5 minutes, and a PRO account at 40 minutes, showing how the quota grows sharply with account tier.](/figures/zerogpu-daily-quota-by-account-en.svg)

One more thing the video skips, and the one I think people trip on most: a Space created from the command line, as in the video, is public by default, and anyone can read a public Space's code and clone the whole thing. If your app needs an API key for some service, never hard-code it; put it in the "Secrets" field on the settings page, where the platform hides it and clones of your Space won't carry it. The docs say the platform also scans for hard-coded keys and warns the owner, but that's cleanup after the fact.

So "$0" is real. It's just a cup that only fills for five minutes a day.

![Two panels compared. In the top panel the key is drawn inside the code block, and the copy made from it carries the key too. In the bottom panel the key sits in a secret field outside the code, and the key slot in the copy is empty.](/figures/secret-field-vs-hardcoded-key-en.svg)

## Further thoughts: I don't code. Does this matter to me?

It does, and the bar is lower than you might think.

The simplest use involves no code at all. The docs say anyone can use existing ZeroGPU Spaces for free, and there are ready-made ones for background removal, photo touch-ups, and speech-to-text. Log in and you get five minutes of GPU time a day, more than enough to fix a few photos now and then.

Building your own isn't hard either. Any AI assistant can write those twenty lines today. Your part is opening an account, pasting the code, and clicking a few buttons. The hardest step in the video was a typo.

What I'd build is small. Older relatives keep sending blurry old photos, so a little page where you drop one in and get a sharper version back, with a link family can open without installing anything. Or a tool where you drop in a meeting recording and get text out. Jobs used a few times a day for a few seconds each fit neatly inside the free quota. The risk runs the other way: build something genuinely useful, share it widely, and many people show up. The quota is charged to each user, and anyone not logged in gets only two minutes a day, so they'll hit "used up for today" fast. It suits you and the people around you; a business built on it would hit that wall fast.

## Further thoughts: when does free stop being enough?

This is the question I most wanted to settle, and I happen to have my own numbers to compare.

vast is a marketplace where people rent out GPUs by the hour: the meter starts when the machine boots and stops when you shut it down. On September 23, 2026, I rented an RTX 3090 there to run a batch of images: $0.22 an hour, 31.8 seconds per image, 49.5 minutes from boot to all 50 images saved, $0.18 in total.

Hold that up against ZeroGPU. If each image also takes about half a minute, a free account's five minutes a day covers roughly ten images. Past the quota, at $1 per 10 minutes, that's $6 an hour, more than twenty times what I paid for the 3090. ⚠️ The cards differ, and ZeroGPU's is much larger, so treat this as a rough estimate.

![Two bars of very different heights: on the left, ZeroGPU paid usage works out to $6 per hour and stands tall; on the right, renting a 3090 at $0.22 per hour is only a thin line.](/figures/per-hour-cost-height-gap-en.svg)

ZeroGPU does have one advantage my run didn't: the docs tell you to load the model when the app starts, so while the Space is awake, later calls don't wait on a download. Of my 49.5 minutes, downloading a 30 GB model took 21; less than half the time went to actual drawing. For a small, occasional job, ZeroGPU saves you exactly that wait.

Side by side (ZeroGPU per the official docs as of 2026-10-02; vast is the price I got on September 23):

| | ZeroGPU, free account | ZeroGPU, PRO | vast, rented RTX 3090 |
|---|---|---|---|
| Monthly fee | $0 | $9 | $0 |
| Daily usage | 5 minutes | 40 minutes, then $1 per 10 minutes | Unlimited, $0.22 an hour |
| GPU | Half an RTX Pro 6000, 48 GB | Same | RTX 3090, 24 GB |
| Wait before you start | New accounts wait 30 days to host | The docs only state the wait for free accounts | Model re-downloads on every boot; 21 minutes for me |
| Good for | Demos, occasional use | A little every day | One big batch |

So here's how I split it now. Demos for other people and my own occasional use go on ZeroGPU's free quota. A big one-off batch means renting a card and shutting it down when done. Running for hours every day is when buying a card starts to make sense. I compared those last two paths earlier in "[Local LLMs: Buy a GPU or Rent One?](/en/blog/runpod-vs-local-gpu-2026-09/)".

![A left-to-right axis of daily usage split into three zones: a few minutes on the free quota, one big batch on a rented card, and hours every day where buying a card starts to make sense](/figures/how-long-per-day-three-zones-en.svg)

![Two time bars compared. The top bar covers the 49.5 minutes of that rental, with the first 21 minutes spent downloading the model and only the rest spent generating images. The bottom bar for ZeroGPU has no download segment at all, so the whole bar is generation.](/figures/wait-before-work-time-split-en.svg)

What actually made me stop and think was his closing line: if you think building AI apps means buying a $5,000 GPU, think twice. He's right. The next thing to think about, once you've thought twice, is how many minutes a day you'll use it.