Step 1: generate one at a time

On the free plan, firing several requests at once got me an HTTP 429 "too many requests" error. Sending them one after another worked every time. If you script the generation, make the loop sequential and back off on a rate-limit response:

import time

class RateLimited(Exception):
    """Raise this from your API wrapper on an HTTP 429."""

def generate_all(prompts, generate, max_tries=5):
    results = []
    for prompt in prompts:
        for attempt in range(max_tries):
            try:
                results.append(generate(prompt))
                break
            except RateLimited:
                time.sleep(5 * 2 ** attempt)  # 5s, 10s, 20s...
        else:
            raise RuntimeError(f"gave up on: {prompt[:40]}")
    return results

generate is whatever function calls your image API. Each image took about 20–30 seconds for me, so a sequential batch of four is still only a couple of minutes.

Step 2: resize and convert to WebP

The model returned 16:9 PNGs at 2048 × 1152. For a content column that's far more than needed. I converted each to a 1600 × 900 WebP, which landed between 100 and 210 KB per file. A small Pillow script does it, stepping quality down until the file fits a size budget:

from pathlib import Path
from PIL import Image

src, out = Path("raw"), Path("web")
out.mkdir(exist_ok=True)
BUDGET = 210_000  # bytes

for png in sorted(src.glob("*.png")):
    im = Image.open(png).convert("RGB")
    im = im.resize((1600, round(im.height * 1600 / im.width)), Image.LANCZOS)
    dst = out / f"{png.stem}.webp"
    for q in range(85, 55, -5):
        im.save(dst, "WEBP", quality=q, method=6)
        if dst.stat().st_size <= BUDGET:
            break
    print(dst.name, im.size, dst.stat().st_size // 1024, "KB")

Step 3: label it in the markup

An AI image that could be mistaken for a real photo should say what it is. I put the label in the visible caption, not just the alt text, and set explicit dimensions so the layout doesn't shift while it loads:

<figure>
  <img src="/img/shed.webp" width="1600" height="900" loading="lazy"
       alt="Small wooden garden shed with a gable roof at the edge of a lawn">
  <figcaption>AI-generated illustration, not a photo of a real build.</figcaption>
</figure>

(The live site is in German, so its captions read "Symbolbild (KI-generiert)".)

Step 4: eyeball every output

Negative prompts help but don't guarantee anything. My prompt said "no people", and one image still had a hand in it. Before an image ships, check for hands, stray text-like shapes and logos.

The prompts, the results and the full list of free-plan limits I ran into are in the write-up on Humabot: I made 4 website images on Higgsfield's free plan.

Humabot is published by Adnenco. The full case study on humabot.cc contains an affiliate link to Higgsfield; if you later upgrade through it, I may earn a commission at no extra cost to you.

How Make counts usage

Make bills in credits. Most actions a scenario performs use one credit each: reading a record, searching, creating a row, sending an email. A two-step automation ("new item → send email") costs roughly 2 credits every time it does real work. Routers and error handlers don't use credits; some AI features use more.

The part people miss: a scheduled trigger costs a credit every time it checks, even when there's nothing new.

The polling maths

On the free plan the fastest schedule is every 15 minutes:

So the rule on the free tier is simple: poll slowly, or don't poll at all.

Three design rules for the free tier

1. Prefer instant triggers (webhooks) where the app supports them. They only fire, and only cost credits, when something actually happens.
2. Schedule the rest every few hours or once a day. Most "notify me" and "copy this to a sheet" jobs don't need 15-minute freshness.
3. Plan around 2 active scenarios. You can build as many as you like, but only two can be switched on at once. This is usually the limit you hit first, before credits.

Free-tier-friendly starter ideas

• RSS → email: check a blog feed once a day and email yourself new posts (~30 checks a month).
• Form → spreadsheet via webhook: runs only when someone submits.
• Weekly summary: once a week, read a few cells and email a report (~4 runs a month).

Any two of these fit comfortably inside 1,000 credits.

Other free-plan limits worth knowing

Maximum 5 minutes per run, 5 MB files, 1 MB of data storage, and no Make API or custom code modules. Unused credits expire at the end of the month. These are the published limits as listed on make.com/pricing in October 2026; the vendor's page is the final word.

I've put the full limits table, paid-plan comparison and FAQ in the complete guide: Make.com free plan: what 1,000 credits a month really buys you.

Humabot is published by Adnenco. The full guide on humabot.cc contains an affiliate link to Make; if you later buy a paid plan through it, I may earn a commission at no extra cost to you.