magicloops.dev

Magic Loops prices every paid plan at $1 USD per 1,000 credits, with a free tier that gives you 8,000 credits plus daily and monthly allowances. Choose Free to test ideas with public Loops, Professional ($20/month) for private Loops and flexible credit use, and Enterprise if you need unlimited credits, on-premise hosting, or SOC 2 compliance. The right plan depends on whether your Loops must stay private and how many runs you expect per month.

The Three Plans at a Glance

What the Free Plan Actually Covers

The Free plan is a real starting point, not a demo:

• 8,000 credits to begin with.
• 250 Gen Credits per day, which covers building and generating Loops.
• 500 Run Credits per month, which covers executing them.
• Public Loops — your creations are visible to the community.

The catch is the split between generation and running. Building is relatively generous (250 per day), but 500 runs per month works out to roughly 16 runs per day. If you build an automation you rely on daily, you will likely hit the run ceiling before the generation ceiling. The other constraint is visibility: public Loops suit experiments, community apps, and learning the platform, but not anything containing private data or a workflow you want to keep to yourself.

How Credits Work on Paid Plans

Paid plans are metered at $1 per 1,000 credits, so your monthly cost scales with usage rather than a fixed feature bundle. Professional is listed at $20/month with "dynamic credits," meaning the credit volume adjusts to what you actually use rather than a hard cap you buy in advance.

Two practical implications:

1. Estimate your run volume first. Count how many times per day your Loops would execute, multiply by 30, and check that against your credit budget. A Loop that runs a handful of times a day is cheap; one triggered by every incoming message or file is not.
2. Generation and running both draw on credits. Building and iterating on a Loop consumes credits too, so heavy experimentation months cost more than steady-state months.

The site does not publish a per-action credit rate, so the exact cost of a single run depends on what the Loop does. Treat the $1/1,000 figure as the conversion rate and confirm consumption on the Compare Plans page before committing.

When Professional Is the Right Choice

Pick Professional if either of these is true:

• Your Loops need to be private. Private Loops are the headline difference from Free, and for most business or personal-data use cases this alone justifies the $20.
• You run Loops regularly. Dynamic credits remove the 500-runs-per-month ceiling and let you pay for what you use at the flat $1/1,000 rate, with dedicated support included.

Skip it if you are still exploring. The Free plan's 250 daily Gen Credits are enough to learn how Loops combine LLMs and code, and you can upgrade the moment privacy or volume becomes a real requirement.

When Enterprise Makes Sense

Enterprise is aimed at large organizations and bundles capabilities the lower tiers do not offer:

• Unlimited credits and unlimited runs — no metering to forecast.
• On-premise hosting — for teams that cannot run workflows in a shared cloud environment.
• SOC 2 compliance — relevant if your procurement or security review requires it.
• 1:1 support and custom models.

This is a sales conversation, not a self-serve checkout. If your organization requires on-premise deployment or a compliance attestation, Enterprise is the only tier that addresses it.

What to Check Before You Decide

Before choosing, verify these on the pricing page:

• The credit cost of your specific Loop type. The $1/1,000 rate is fixed, but consumption per run is not published in the summary — check the Compare Plans view.
• Whether "dynamic credits" has a floor or overage behavior beyond the $20 base.
• What counts as a Gen Credit versus a Run Credit on paid plans, since the Free tier separates them and paid tiers describe credits more generally.
• Enterprise contract terms — pricing is quote-based, so hosting and compliance scope are negotiated.

A Simple Decision Rule

• Learning or building public apps → Free.
• Private Loops, or more than ~500 runs a month → Professional at $20/month plus $1 per 1,000 credits.
• Unlimited volume, on-premise hosting, or SOC 2 required → Enterprise.

The platform reports over 3.5 million Loop runs from 65,000 users, so the Free tier is a genuine on-ramp rather than a trial — start there, and upgrade when privacy or run volume forces the decision.

Magic Loops' community gallery showcases apps across content creation, personal utilities, study help, data insights, creative fun, and games. You can browse by category or scan the full list, and each app card shows a rating (most examples sit between 4.7 and 4.9). The gallery is useful both for finding a ready-made tool and for seeing what a "Loop"—a mix of LLM prompts and code—can realistically produce before you build your own.

Categories you can browse

The gallery organizes apps under these filters:

• Content Creators
• Personal Utilities
• Study Helpers
• Data Insights
• Creative Fun

Individual apps also carry their own tags, which are narrower than the browse categories—for example Games, Art, Productivity, Education, Finance, and Photography. So a single app can sit under a broad filter and still be labeled with a specific use case.

Example apps and what they do

The spread is telling: some apps are pure entertainment (Magic Alchemy, Name Destiny), some are practical utilities (Expense Tracker, TL;DR Anything), and some are creative transformations (Ghibli Transformer, Pro Headshot AI). That range reflects the platform's pitch—combining LLMs and code to build "simple automations" without writing code.

How to use the gallery to pick or build an app

1. Start with your task, not the category. Decide what you actually need—summarizing links, tracking spending, generating ideas—then scan the matching filter (e.g., Personal Utilities or Data Insights).
2. Check the tag and rating. A 4.7–4.9 rating on a small set of examples suggests community satisfaction, but treat ratings as a rough signal rather than a guarantee for your specific use case.
3. Open an app that's close to your need. If one already does most of what you want, use it directly rather than rebuilding.
4. Use near-misses as templates. If nothing fits exactly, the closest app shows you the shape of a working Loop—its inputs, outputs, and complexity—so you can judge whether your idea is a good fit before creating your own.
5. Create your app when the gap is clear. The gallery's "Create App" path is the next step once browsing tells you what's missing.

What the gallery tells you about platform limits

The examples are deliberately small in scope: a summarizer, a tracker, a generator, a transformer. None of the showcased apps imply heavy infrastructure or complex multi-user systems. That's consistent with the platform's framing as a place for "simple automations" and "apps without coding." If your idea resembles one of these patterns—take an input, run it through an LLM step plus some code, return a result—the gallery is good evidence it's buildable here. If your idea needs something far outside these patterns, the gallery gives you no proof either way, and you should test a minimal version first.

The site also cites over 3.5 million Loop runs from 65,000 users, which indicates the gallery reflects real usage rather than demos only—though the specific apps shown are a curated selection, not the full catalog.

A Loop on Magic Loops is a reusable automation that combines LLM steps with code to perform one focused task. Apps in the gallery are built on top of these Loops: the Loop does the work (summarize a URL, generate a headshot, track expenses), and the app wraps it in an interface other people can use. This matters if you want to build AI-native tools without writing a full application from scratch.

The core idea: LLM steps plus code

Magic Loops describes itself as a platform to "combine LLMs and code to create simple automations." A Loop is that automation unit. Instead of chaining prompts by hand every time, you define the sequence once — where the model reasons or generates, and where deterministic code handles the rest (parsing input, formatting output, calling a service, doing math).

That split is the practical value. LLMs are good at interpretation and generation but unreliable at exact operations; code is the reverse. A Loop lets each part do what it's good at, and the result is repeatable rather than a one-off chat.

For example, a summarization Loop might take a URL or block of text as input, use an LLM step to condense it, then use code to enforce a fixed output shape — a five-sentence summary plus three key points, as the "TL;DR Anything" app in the gallery does. Run it again with new input and you get the same structure every time.

From Loop to published app

The gallery shows how Loops become products. Each listed app — Magic Alchemy, Ghibli Transformer, Idea Builder, Expense Tracker, Pro Headshot AI — is a finished experience built on Loop logic, tagged by category (Games, Art, Productivity, Finance, Education, Photography) and rated by users.

The relationship is worth being precise about:

So a Loop is the engine; an app is the vehicle. The gallery's "Explore useful Loops powering amazing Apps" framing makes this explicit — the Loops are the reusable machinery, and the apps are what the community of makers ships on top of them.

Reuse is the point

Because a Loop is a discrete, self-contained automation, it can be reused across apps rather than rebuilt each time. That's what makes the "no-code, all-code" positioning coherent: non-technical makers assemble Loops into apps, while the Loops themselves can still contain real code where precision matters.

The scale signals back this up. The site reports over 3.5 million Loop runs from 65,000 users — a volume that only makes sense if Loops are reused across many apps and many end users, not built one-to-one with each app.

What this means if you're evaluating it

• If you want to build a focused AI tool (a summarizer, a generator, a tracker), the Loop model means you define the automation once and reuse it, rather than re-prompting each time.
• If you want to see what's possible first, browse the gallery — the published apps are working examples of Loops in production, with categories and ratings to gauge fit.
• On cost, the site states every paid plan is $1 USD per 1,000 credits, with a free tier offering 8,000 credits, 250 generation credits daily, and 500 run credits monthly. Check the pricing page for current plan details before committing, since credit consumption depends on how often your Loops run.

The short version: a Loop is the reusable LLM-plus-code automation, and an app is what you get when you put a usable front end on it. Understanding that split is the key to reading the gallery — and to deciding whether to build your own.

You can create your first app on Magic Loops by opening the site, choosing Create App (or Get started for free), and building on top of the platform's no-code, AI-native app builder. The free tier gives you 8,000 credits, 250 Gen Credits per day, and 500 Run Credits per month, which is enough to try the builder and run a simple app before you decide whether to pay. If you want to reuse something that already works, start from a community app or Loop instead of a blank canvas.

What you need before you start

• A Magic Loops account. The site offers a free "Get started" path; the exact sign-up fields aren't described in the available material, so expect a standard account creation step.
• A clear idea of the app's single job. The gallery examples are narrow and task-specific: a TL;DR summarizer that takes a URL or text and returns a five-sentence summary plus three key points, an expense tracker with imports and visual summaries, or a photo transformer that turns images into Ghibli-style art.
• No coding required. Magic Loops describes itself as "the no-code, all-code platform" that combines LLMs and code to build AI-native apps.

Step-by-step: from landing page to a running app

1. Enter the builder

From the homepage, use Create App or Get started for free. Both lead into the app creation flow. The homepage also has a Watch demo link if you want to see the builder in action before committing.

2. Pick your starting point

You have two practical options:

The gallery is organized by category — Content Creators, Personal Utilities, Study Helpers, Data Insights, Creative Fun, Games, Art, Productivity, Education, Finance, Photography — so browsing by category is the fastest way to find a close match. Community apps show ratings (most listed examples sit around 4.7–4.9), which helps you judge whether a starting point is solid.

3. Define what the app does

Describe the task in plain terms: what the user provides, what the app should return, and in what format. The TL;DR Anything example is a good model — input is a URL or text, output is a fixed-length summary plus three key points. Keeping the output format explicit is what makes an app feel finished rather than experimental.

4. Combine LLM steps with code

Magic Loops is built around combining LLMs and code inside a Loop. Use the LLM step for language work (summarizing, generating, transforming) and code steps for anything deterministic (formatting, calculations, data handling). This split is the core mechanism: the LLM handles judgment, the code handles precision.

5. Test with real inputs

Run the app with the kind of input a real user would give — a long article for a summarizer, a messy CSV for a tracker. Check that the output matches the format you specified. The free tier's 500 monthly Run Credits and 250 daily Gen Credits are the budget you're testing against, so a handful of runs is cheap.

6. Publish and share

Once the app behaves correctly, publish it so it appears in the community gallery alongside the other apps. The gallery is the discovery surface — the homepage explicitly invites you to "explore popular Apps created by our community of makers."

What the free plan actually covers

The free plan includes:

• 8,000 credits to start
• 250 Gen Credits daily
• 500 Run Credits monthly
• Public Loops
• Community Support

That's enough to build and test a small app. The limits to watch are the monthly Run Credits (they cap how many times your app can be executed per month) and the daily Gen Credits (they cap generation steps). If you hit those ceilings while still experimenting, that's the signal to look at paid plans rather than a sign you've done something wrong.

When to upgrade

Every paid plan is priced at $1 USD per 1,000 credits, which makes cost easy to estimate from usage. The Professional plan at $20/month adds Private Loops, Dynamic Credits, and Dedicated Support — the meaningful change is privacy, since free-tier Loops are public. Enterprise adds unlimited credits, on-premise hosting, unlimited runs, SOC 2 compliance, 1:1 support, and custom models, aimed at large organizations. If your app handles anything you wouldn't want public, the privacy difference alone justifies Professional.

Where to get help

• Community Support is included on the free plan.
• Discord is linked from the site footer and is the place for peer help from other makers.
• Dedicated Support comes with Professional; 1:1 Support with Enterprise.
• The gallery itself is a resource — studying how existing apps are structured is often faster than asking.

Common sticking points

• Vague output formats. If you don't specify the shape of the result (five sentences plus three points, a table, a score), the app will drift between runs.
• Overloading one app. The successful gallery examples each do one thing. Split multi-purpose ideas into separate apps.
• Burning Run Credits on debugging. Test logic with a few representative inputs rather than many near-identical ones.
• Assuming free means unlimited. The credit structure is explicit; plan your testing around the monthly and daily caps.

The platform reports over 3.5 million Loop runs from 65,000 users, so there's a large body of existing work to learn from. Start with a narrow task, borrow structure from the gallery, and use the free credits to validate before paying.

Magic Loops is a no-code, all-code platform for building AI-native apps and simple automations by combining large language models (LLMs) with code. It suits makers, non-coders, and small teams who want to launch a working app quickly rather than spend months on development. You can start on a free plan with 8,000 credits, then move to paid plans at $1 USD per 1,000 credits. It is a third-party product, not an official service of any AI model provider.

How Magic Loops Works

The core idea is that an app is assembled from Loops — small units that pair an LLM step with code. Instead of writing a full application from scratch, you describe or select the behavior you want, and the platform wires the model calls and logic together. The site describes the result as “professional AI-native apps in minutes, not months.”

Two terms appear on the pricing page and are worth knowing before you start:

• Gen Credits — used when generating or building with the platform (the free plan includes 250 per day).
• Run Credits — used when your app actually runs (the free plan includes 500 per month).

That split matters: a free account can build and test, but heavy usage of a finished app will draw on Run Credits.

What You Can Build

The community gallery shows the range of apps makers have published. These are real examples with ratings, grouped by category:

The pattern across these: each app takes a simple input (a photo, a URL, a name, a list of expenses), runs it through an LLM-plus-code Loop, and returns a useful or entertaining output. That is the shape of app Magic Loops is best at.

Who It Is For

• Non-coders with a specific idea — if your app is “take input X, process it with AI, show result Y,” the platform is a strong fit.
• Makers who want to ship fast — the gallery and templates give you a starting point instead of a blank page.
• People testing an idea — the free tier (8,000 credits, public Loops) lets you validate before paying.

It is less suited to apps that need complex custom backends, fine-grained infrastructure control, or heavy private usage on a budget — those push you toward the Professional plan ($20/month, private Loops, dynamic credits) or Enterprise (unlimited credits, on-premise hosting, SOC 2 compliance, custom models).

Plans at a Glance

Every paid plan is billed at $1 USD per 1,000 credits. The site does not state whether the free plan requires a login to create apps, so treat account requirements as something to confirm when you sign up.

Getting Started

1. Go to magicloops.dev and choose Create App (or Get started for free).
2. Browse the community gallery first — pick an app close to your idea and study its inputs and outputs.
3. Build your Loop: define the input, the LLM step, and the code logic that shapes the result.
4. Test with Gen Credits, then publish and share; real usage draws on Run Credits.
5. Verify it works by running it with sample inputs before promoting it.

Common snag: watching Gen Credits but ignoring Run Credits. If your app gets shared widely, monthly Run Credits on the free plan can run out quickly — check usage before you invite users.

The platform reports over 3.5 million Loop runs from 65,000 users, so there is a sizable community to learn from. Start with the free tier, build one small app end to end, and upgrade only when private Loops or higher credit volume become necessary.