DEV Community: ModelFild

One API key, 700+ models: why I stopped juggling vendor accounts

ModelFild — Sun, 15 Nov 2026 05:13:33 +0000

I work on ModelFold. This is a walkthrough of the public catalog and the OpenAI-compatible API as they stood on 14 November 2026. Prices move. Treat the live pricing page as the invoice, not this article.

Most AI side projects die in the accounts tab.

You start with one chat model. Then you need an image model for the landing page, a video model for the demo, a TTS voice for the onboarding clip. Each vendor wants its own key, its own SDK, its own dashboard, and a card on file. Switching a model is never "change the model string". It is a new account, a new request shape, and a new invoice.

ModelFold is the opposite of that setup. One prepaid-credit account. One OpenAI-compatible key. A public catalog that, on 14 November 2026, listed 700+ models from 92 providers — 702 marketplace listings if you count variants. Chat, video, image, audio, 3D and office are on the same bill. That catalog size is why we describe it as the world's largest AI model gateway; the number you can verify is the directory, not a third-party ranking.

Create a key here: modelfold.ai.

What "one key" actually means

The OpenAI-compatible base URL is:

https://modelfold.ai/v1

Chat, image, video and audio share the same host and the same Authorization: Bearer header. You change the path and the model id.

export MODELFOLD_API_KEY="your_key"

# list what you can actually call today
curl -sS https://modelfold.ai/v1/models \
  -H "Authorization: Bearer $MODELFOLD_API_KEY"

A chat call looks like any other OpenAI-style client:

curl https://modelfold.ai/v1/chat/completions \
  -H "Authorization: Bearer $MODELFOLD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5-5",
    "messages": [{"role":"user","content":"Summarize this PR in four bullets."}],
    "max_tokens": 400
  }'

An image call uses the same key on a different path:

curl https://modelfold.ai/v1/images/generations \
  -H "Authorization: Bearer $MODELFOLD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2",
    "prompt": "A whiteboard photo of a 700-model API gateway, documentary lighting",
    "n": 1
  }'

Video is the same pattern on /v1/videos/generations. Model ids come from GET /v1/models or from the market, not from memory. The catalog changes.

Python, if you already have the OpenAI SDK:

from openai import OpenAI

client = OpenAI(
    api_key="your_key",
    base_url="https://modelfold.ai/v1",
)

chat = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Give me a 3-step plan to batch-generate product stills."}],
)
print(chat.choices[0].message.content)

That is the whole point: the application code stays still. The model field is the switch.

Coding agents: Claude Code, Codex, Cursor

The same account also speaks the protocols those tools already use.

Claude Code CLI — Anthropic-compatible gateway. The client appends /v1/messages itself, so the base URL stops at /anthropic.

export ANTHROPIC_BASE_URL=https://modelfold.ai/anthropic
export ANTHROPIC_AUTH_TOKEN=$MODELFOLD_API_KEY
export ANTHROPIC_MODEL=claude-sonnet-5-5
export ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-5-5
export ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-5-5
export ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-5-5

Haiku is required. Background tasks will ask for a Haiku-tier id; if it is missing they fall back to a vendor name ModelFold does not serve. Discover ids with GET https://modelfold.ai/anthropic/v1/models. Walkthrough: Claude Code CLI.

Codex CLI — OpenAI Responses API. Codex appends /responses itself.

model = "gpt-6-astra"
model_provider = "ModelFold"
[model_providers.ModelFold]
name = "ModelFold"
base_url = "https://modelfold.ai/openai/v1"
env_key = "MODELFOLD_API_KEY"
wire_api = "responses"

Put this in ~/.codex/config.toml (user-level; project-level model_providers is ignored). List slugs from GET https://modelfold.ai/openai/v1/models. Guide: Codex CLI.

Cursor — override the OpenAI base URL if your plan exposes that setting:

URL: https://modelfold.ai/v1
API Key: your ModelFold key
Model ID: claude-opus-5-5

The Cursor page is a configuration note, not a claim that every agent feature was re-tested in that client. Guide: Cursor.

Price: a dated snapshot, not a slogan

Billing is prepaid credits. No monthly seat. 200 credits = $1 USD on the public packs ($5 → 1,000 credits). Failed generations are not charged. Credits do not expire.

The homepage comparison table is computed against the same model's official list price. I am not going to freeze a "save X%" headline here, because that number is regenerated from the live catalog. On 14 November 2026 the public table included rows like these:

Model	Unit	ModelFold	Official list on our table
GPT Image 2 (text to image)	per image	$0.04	$0.219
Kling 4.0 keyframe, 720p, 5s	per video	$0.855	$1.1775
Seedance 2.5, 480p, 5s	per 5 seconds	$0.84	see live row
Claude Haiku 4.5 input	per 1M tokens	$0.32	$1.00
Claude Fable 5.2 input	per 1M tokens	$3.84	$8.00

Those dollars are display prices from modelfold.ai/pricing on that date. Larger packs add bonus credits; do not reverse a model rate from the $50 or $500 pack. If a row is marked as an estimated official reference, treat it as a reference, not a quote from the vendor's invoice.

Direct routes, not a mashed-up "almost that model"

The product claim on the homepage is straightforward: each listing calls the original model, with more than one route behind it so a busy path can fail over. A generation that fails is $0. You are billed for a result.

I did not run a paid generation while writing this article. The curl examples above are the request shape. Confirm a key with GET /v1/models before you spend.

When this is the wrong tool

If you already have a single-vendor contract with committed volume, stay there. If you need a model that is not on the catalog, it is not on the catalog — check the market rather than assuming a name from a launch blog. If you are serving weights on your own GPU, this is a hosted API, not a local runtime.

If you are tired of five dashboards for one prototype, one key is the whole pitch.

Register, create a key, and call the catalog: https://modelfold.ai/?utm_source=devto&utm_medium=article&utm_campaign=700-launch

Chinese homepage: https://modelfold.ai/zh/ · Market: https://modelfold.ai/market · Machine-readable catalog: https://modelfold.ai/llms.txt

Claude Fable 5.2 Is Now on ModelFold: Bring a Problem Worth Solving

ModelFild — Thu, 12 Nov 2026 13:59:31 +0000

Claude Fable 5.2 arrived on ModelFold today, November 12. You can try it in the web chat or connect through the API. A useful place to start is a problem you are already trying to solve.

Anthropic positions Fable 5.2 for demanding reasoning and agentic work that needs sustained progress. Think debugging a complicated codebase, working across a stack of documents, or untangling a technical question with several dependent steps.

The published specifications include a one-million-token context window and up to 128,000 output tokens, with text and image input and text output. That creates room for more source material and a fuller explanation. Actual limits in each ModelFold interface are listed on the relevant page.

We ran two small tests through ModelFold to see what that looks like in practice.

The first described an order endpoint where clients retry after a timeout and the server has no idempotency key. Fable identified the risks of duplicate orders and charges, suggested idempotency keys backed by a unique constraint, and outlined checks for concurrency and timeout retries. In three lines, it connected the bug, the fix, and a way to verify the fix.

The second was a project handoff exercise. It kept “development complete,” “copy awaiting confirmation,” “mobile acceptance testing incomplete,” and “not yet deployed” separate. It did not invent dates or treat a passing build as proof of a successful release. That kind of restraint matters when a summary will guide somebody else's next action.

Two short tests are no substitute for a broader evaluation. They do suggest a useful question to ask of a reasoning model: does the answer leave you with a next step you can actually check?

Bring your code, documents, or a difficult question and give it a try. For an existing API client, use the model ID claude-fable-5-2 with /v1/chat/completions.

ModelFold: https://modelfold.ai

Model details: https://modelfold.ai/models/claude-fable-5-2

Claude Fable 5.2: Can It Move a Stuck Engineering Task Forward?

ModelFild — Thu, 12 Nov 2026 12:03:54 +0000

When a new model arrives, the first question is usually how well it scores. My first question is more practical: would I give it the problem I've been stuck on for two days?

That might be a bug spanning several layers of a service, a set of conflicting requirements, or a handoff that leaves the next engineer guessing what actually shipped. A useful answer should help someone take the next step and check whether it worked.

Anthropic released Claude Fable 5.2 on November 9, 2026, positioning it for demanding reasoning and long-horizon agentic work. Those are broad claims. I wanted to start with something small enough to inspect.

On November 12, I ran two short prompts through ModelFold using claude-fable-5-2. Both returned successfully through the Chat Completions endpoint. Neither was a benchmark, and neither involved running a real payment flow or changing a production system.

Test 1: Make a code review actionable

The first prompt described an order endpoint:

The client retries after a timeout.
Every request creates an order and initiates a charge.
There is no idempotency key.

I asked for exactly three short lines: risk, fix, and verification. The prompt and response were in Chinese; the following is an English translation of the response:

Risk: Timeout retries are treated as new requests, creating duplicate orders and charges, with financial losses and customer complaints.

Fix: Have the client send an idempotency key, enforce a unique constraint on the server, and return the original result for duplicate requests.

Verification: Send concurrent requests and timeout retries with the same key; confirm there is only one order, one charge, and a consistent response.

The last line is what interested me. “Add an idempotency key” gives you a direction. Specifying concurrent requests, timeout retries, and the expected order and charge counts gives a developer or tester something concrete to work with.

It is still only review advice. The model did not execute the payment system or validate its charge handling. An implementation would also need to address transactions, in-progress requests, and recovery from failures.

For this input, the answer was a useful starting point for implementation and acceptance criteria. It was not evidence that the system had become safe.

Test 2: Keep a handoff honest

The second prompt described a search page with a deliberately mixed status:

Development is complete and the local build passes. It has not been deployed to production. Product has not approved the empty-state copy, and mobile acceptance testing in the test environment has not been done.

The request was to organize this into three lines—completed, pending confirmation, and next steps—using only the supplied facts, without adding dates or guessing an outcome.

Translated from the Chinese response:

Completed: Development of the new search page is complete, and the local build passes.

Pending confirmation: Product has not yet approved the empty-state copy.

Next steps: Mobile acceptance testing in the test environment has not been done, and production deployment is still pending.

There is nothing spectacular about that output. Its value is that it preserves the distinction between “implemented,” “build passes,” and “live.” It also leaves unapproved copy and untested mobile behavior unresolved.

A handoff becomes much less useful when a polished summary quietly turns unfinished work into completed work. In this example, the model kept those boundaries intact.

Two short responses cannot establish general reliability or rank a model against its competitors. They do suggest two worthwhile things to test further: whether technical advice includes a way to verify it, and whether summaries preserve the limits of the evidence.

What the larger context window could help with

The official specifications list a one-million-token context window and a maximum output of 128,000 tokens, with text and image input and text output.

I did not test those limits, image understanding, or sustained autonomous work. Nor should the official limits be read as a guarantee that every integration exposes the full capacity.

What the larger window suggests is room to provide a more complete problem: symptoms, relevant code, previous attempts, constraints, and the deliverable you need. It does not remove the need to organize that material.

For a code review, I would start with something like:

Here is the endpoint, the error, and the causes I have already ruled out. Rank the three most likely remaining problems by the available evidence. Propose the smallest change and verification steps. Mark any conclusion that needs more evidence.

For conflicting requirements:

Find contradictions across these three documents. Identify the original passage for each conflict. Do not invent commitments to reconcile them.

For a screenshot:

Check whether the primary button, error messages, and form labels are ambiguous. Explain the visual evidence for each issue.

These are suggested follow-up tasks, not tests I ran for this article. The common thread is specifying what a usable result should contain before asking the model to produce it.

Start with the task you can evaluate

Anthropic recommends starting with Opus 5.5 for most coding and knowledge work, then considering Fable as task complexity warrants. That seems like a sensible way to approach it.

For a small copy change or a straightforward summary, start with the model you already know. For a difficult problem, prepare the context and acceptance criteria, then see whether Fable 5.2 finds a missing condition, explains uncertainty, or proposes a next step you can check.

Output length alone is a poor measure of progress. A short answer that identifies the untested assumption can be more useful than pages of plausible explanation.

Trying the same model through ModelFold

ModelFold added Claude Fable 5.2 on November 12. At modelfold.ai, search the model marketplace for Claude Fable 5.2 and open its detail page for the web chat entry point and API examples.

For an existing integration, use the model ID claude-fable-5-2. ModelFold provides Chat Completions at /v1/chat/completions and a Claude Messages interface; follow the example for the interface you choose and check its request format. Both tests above used the former.

As checked on November 12, the ModelFold detail page displayed these rates:

Usage	Credits per million tokens	Approximate USD per million tokens
Input	768	$3.84
Output	3,840	$19.20

These are per-million-token rates, not a fixed price per question. Input and output are billed separately, thinking tokens are billed as output, and including conversation history increases input usage. Refer to the current page and actual usage settlement for subsequent charges.

My suggestion is to start with a small problem whose background you understand and whose result you can inspect. Ask for one pass, then check what it resolved and what it left open before giving it a larger task.

That is how I want to evaluate Fable 5.2: can it turn a vague problem into something testable, attach verification to a proposed fix, and leave missing information visibly unresolved?

Pick one of those tasks you've had parked for a week. Give it the evidence, define what progress would look like, and see whether the next step becomes clearer.

Call GPT Image 2.6 on ModelFold

ModelFild — Sat, 07 Nov 2026 05:15:04 +0000

GPT Image 2.6 is available on ModelFold through one API key and one endpoint. Six model IDs cover the tier and the task. The model page Playground shows the form and a built-in sample before you write the call.

This note is from the ModelFold team. It describes how to integrate the model. Capabilities below were read from the model page and the API docs on November 7, 2026. If those pages change, the pages win.

The model page lists the provider as OpenAI.

Six model IDs

Model ID	Use
gpt-image-2-6/economy-text-to-image	Economy, text to image
gpt-image-2-6/economy-image-to-image	Economy, image to image
gpt-image-2-6/flare-text-to-image	Flare, text to image
gpt-image-2-6/flare-image-to-image	Flare, image to image
gpt-image-2-6/sunburst-text-to-image	Sunburst, text to image
gpt-image-2-6/sunburst-image-to-image	Sunburst, image to image

The page describes Flare as the faster option and Sunburst as the option aimed at detail and consistent edits. Both support 1K, 2K and 4K, for text to image and image to image. Economy stays at 1K. It returns PNG, and Economy text to image can also return GIF.

Try it in the browser

English is the default site, with no language prefix:

https://modelfold.ai/models/gpt-image-2-6#playground

You can view the six tiers, the prefilled form and the sample output while logged out. Run asks you to sign in. The screenshots below were taken logged out on November 7, 2026. The pictures are the page's own samples, not new generations for this article.

Economy text to image. The form shows aspect ratio, background, output format, and the GIF frame fields used by text to image.

Flare text to image. This tier adds resolution. The sample on the page is a GIF.

Sunburst text to image. Resolution, background and output format match Flare text to image.

Sunburst image to image. The reference sits on the left. The sample result sits on the right.

The API

Text to image and image to image both use:

POST https://modelfold.ai/v1/images/generations

Send Authorization: Bearer and Content-Type: application/json. The call waits until the image is finished. The image address is url inside data. There is no separate status poll, and you should not send a callback URL.

Keep the key in your own environment. The samples use the placeholder YOUR_MODELFOLD_API_KEY. Do not paste a real key into the command or into a repository.

Economy text to image, 1K PNG:

curl https://modelfold.ai/v1/images/generations \
  -H "Authorization: Bearer YOUR_MODELFOLD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-image-2-6/economy-text-to-image","prompt":"A glass bottle on a white table, soft daylight, product photo.","aspect_ratio":"1:1","output_format":"png"}'

import json
import urllib.request

key = "YOUR_MODELFOLD_API_KEY"
body = json.dumps({
    "model": "gpt-image-2-6/economy-text-to-image",
    "prompt": "A glass bottle on a white table, soft daylight, product photo.",
    "aspect_ratio": "1:1",
    "output_format": "png",
}).encode()
req = urllib.request.Request(
    "https://modelfold.ai/v1/images/generations",
    data=body,
    headers={
        "Authorization": "Bearer " + key,
        "Content-Type": "application/json",
    },
    method="POST",
)
# The timeout is a client limit, not a limit published by the API. The call waits until generation finishes.
with urllib.request.urlopen(req, timeout=300) as resp:
    data = json.load(resp)
print(data["data"][0]["url"])

Image to image must include input_urls. This URL is a public sample already hosted on the site, used here only to show the field.

curl https://modelfold.ai/v1/images/generations \
  -H "Authorization: Bearer YOUR_MODELFOLD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-image-2-6/economy-image-to-image","prompt":"Turn this product photo into a colored-pencil sketch on ivory paper. Keep the shape and the lettering.","aspect_ratio":"auto","output_format":"png","input_urls":["https://modelfold.ai/examples/gpt-image-2-6/gpt-image-2-6_flare-image-to-image-mw5vq7bn-um2v09.webp"]}'

Flare and Sunburst use the same path with a different model. Those tiers accept resolution (1K, 2K or 4K). For a GIF, set output_format to gif and send frame_count plus frame_duration_ms. Omit resolution on Economy.

Parameters

From the model page:

Parameter	Supported values
prompt	1 to 20,000 characters
input_urls	Required for image to image. Up to 16 public JPEG, PNG or WebP URLs, up to 30 MB each
resolution	Flare and Sunburst: 1K (default), 2K, 4K. Economy is 1K only; omit this field
aspect_ratio	Flare and Sunburst: auto, 1:1, 3:2, 2:3, 4:3, 3:4, 5:4, 4:5, 16:9, 9:16, 2:1, 1:2, 21:9, 9:21, 3:1, 1:3. Economy: auto, 1:1, 16:9, 9:16, 3:2, 2:3, 21:9, 4:3
background	auto, opaque or transparent. Applies only at 1K
output_format	Flare and Sunburst: png, jpeg, webp; text to image also gif. Economy: png; text to image also gif
frame_count	GIF on text to image only. Flare and Sunburst: auto, 4, 9, 16. Economy text to image also 25, 36, 64
frame_duration_ms	Integers from 20 to 2000. The page says values are rounded to 10 ms

One task per request. The page says there is no batch count and no quality parameter. GIF is text to image only. SVG is not offered.

Where it fits

Using only what the page already exposes:

Text to image. The built-in samples include product photos and text inside the picture.
Edits from reference images. Image to image sends input_urls. The Playground shows the reference and the sample result first.
GIF from text to image. The Flare text-to-image sample on the page is a GIF.
2K or 4K by choosing Flare or Sunburst and sending resolution.

The page does not publish a measured ranking that one tier "looks better." Use its own description of Flare, Sunburst and Economy when you pick a model ID.

Start

Create an account at https://modelfold.ai/signup and sign in.
Open https://modelfold.ai/account?tab=keys and create an API key. Keep it in an environment variable or a secret store.
Call the endpoint above with curl or Python. All six model IDs share that key and that URL.
To inspect the form and the samples first, open the Playground and switch among the six tiers.

The model page shows a Commercial use label. Read the current terms before you ship with the outputs: https://modelfold.ai/terms

Pay for AI API Credits with USDC or USDT: ModelFold's Crypto Top-Up Guide

ModelFild — Fri, 06 Nov 2026 11:57:00 +0000

You have a model to try and an app to build. Then checkout asks for a card that works internationally—and yours doesn't. Or you already hold stablecoins and would rather spend those than enter card details for another service.

ModelFold now supports cryptocurrency top-ups with USDC and USDT-family assets on the networks listed below. You can fund your AI usage from a compatible wallet or exchange without using a bank card for the top-up.

Disclosure: this guide is from the ModelFold team. Payment options and fees were checked against the live configuration on November 6, 2026. Always review the current checkout before sending funds.

Card-free does not mean anonymous

If your goal is to avoid sharing card details, a stablecoin payment provides another route. It is not a promise of anonymity: you still sign in to a ModelFold account, and the payment is associated with your recharge order. Transfers also leave public on-chain records. An exchange or wallet service may have its own identity requirements.

Which tokens and networks are available?

These combinations are currently enabled:

Network	Accepted assets shown at checkout
Base	USDC
Arbitrum One	USDC, USDT0
BNB Chain	Binance-Peg USDC, Binance-Peg USDT
Polygon PoS	USDC, USDT0
Ethereum	USDC, USDT
Tron (TRC20)	USDT

The payment category is labeled USDC / USDT, but the asset variant matters. USDT0 and Binance-Peg assets are identified separately above. Base currently supports USDC here; do not send USDT on Base. Match the network and the exact token contract displayed in your order, rather than relying on the ticker alone.

How to top up

Sign in and open Account → Wallet.
Choose your recharge amount and Cryptocurrency (USDC / USDT). Select the token and network before creating the order. Available payment methods can depend on language and region.
Choose Connected wallet when available, or Manual transfer. Tron uses manual transfer.
Review the recharge amount, crypto fee, any network surcharge, and the final amount due.
Complete the payment before the order's countdown expires, then wait for the checkout to show Payment credited. Check your Wallet balance and recharge record afterward.

With a connected wallet, verify the wallet through the signature request, then review and confirm the transfer in your wallet. The checkout fills the amount automatically and does not add a manual-payment identifying fraction. Connecting or signing alone does not complete the payment.

For a manual transfer, copy the receiving address and send the exact amount, including every displayed decimal place. The order includes a small identifying fraction so the incoming transfer can be matched to it. The QR code supplies the address only; enter the amount yourself. If you withdraw from an exchange, account for its withdrawal fee so the full exact amount reaches the receiving address.

Orders have a 30-minute payment window. Do not initiate a new transfer to an expired order. If you already sent a transaction, check its status before trying again; a pending confirmation is not a reason to pay twice. Keep the order reference and transaction hash if you need support.

What you pay, and what becomes credits

Crypto payments currently add a 5% fee to the recharge price. There is also a fixed checkout surcharge of $3 on Ethereum or $1 on Tron; the other networks listed above currently have no fixed checkout surcharge. Your wallet's network gas fee or exchange withdrawal fee is separate.

Manual transfers add an identifying fraction of up to 0.0999 tokens. Your order shows the final amount to send.

Credits are calculated from the original recharge amount. The crypto fee, network surcharge, and identifying fraction do not earn credits, and are not deducted from the package's advertised credits.

For example, the current $5 package provides 1,000 credits. Paying for it with a connected wallet using USDC on Base means a checkout amount of 5.25 USDC, plus the network gas fee paid by your wallet. A manual payment for the same package adds the order's identifying fraction, so copy the actual order amount rather than sending 5.25 USDC from this example.

An eligible first recharge currently receives 10% extra credits. For that $5 package, that means 1,000 package credits plus 100 bonus credits: 1,100 credits total. Eligibility is based on whether the account has previously topped up, not whether this is its first crypto payment.

Credit arrives after the transfer is matched and the required blockchain confirmations are reached. Timing depends on the network and payment processing; this is not an instant-settlement promise. Sending the wrong asset, rounding the amount, or allowing a withdrawal fee to reduce the received amount can prevent automatic crediting.

One API integration, a shared balance across models

Once the recharge is credited, the balance funds usage through ModelFold. Its API documentation covers chat, image, video, and speech models behind one service and API key. Browse the model catalog for current availability and pricing.

Create your own key under Account → API keys. For a read-only discovery request, set MODELFOLD_API_KEY privately in your shell and run:

curl https://modelfold.ai/v1/models \
  -H "Authorization: Bearer $MODELFOLD_API_KEY"

Choose an available chat model's exact ID for a request to /v1/chat/completions. Images, videos, and audio use their respective generation endpoints and model-specific parameters. One integration and balance simplify access across the catalog; they do not mean every model accepts the same payload or that every model on the market is supported.

The practical change is at checkout: if a bank card was the missing piece, you now have a stablecoin option for funding the same ModelFold account and API workflow.

Claude on ModelFold: No Proxy/VPN Needed, Stable and Reliable Workflows

ModelFild — Thu, 05 Nov 2026 10:13:03 +0000

Using Claude for everyday development starts with access, then failure handling and budgeting. ModelFold highlights two practical benefits: no proxy/VPN needed from mainland networks where direct access is available, so you can open the site and configure Claude Code / API without setting up your own proxy or VPN; and stable and reliable workflows supported by explicit error detection, refunds and credit settlement.

ModelFold offers Claude models, Claude Code integration and usage-based billing. Here, “stable and reliable” refers to the verifiable handling mechanisms described below. Its approach to affordability is straightforward: no subscription is required, so you can start with signup credits and add funds as needed.

The model names and top-up information below were checked on November 5, 2026. Current site configuration and settlement records take precedence if anything changes.

No proxy/VPN needed from mainland networks: fewer setup steps

You do not need to prepare your own proxy or VPN to access ModelFold on networks that allow direct access. Open the site from your mainland network, then follow the guide to point Claude Code or your application's API configuration to ModelFold and use your own API key.

Our local connectivity check explicitly disabled curl proxy settings: the ModelFold homepage returned HTTP 200, while /anthropic/v1/models and /anthropic/v1/messages returned the expected HTTP 401 missing-credentials response. This confirms direct access to the site and the API authentication layer from the tested network. It does not verify model generation or establish reachability across every region, carrier or corporate network. Check from your own network before connecting your workflow.

“No proxy/VPN needed” refers to the user-side network setup for accessing ModelFold. Normal use still requires an account, a valid API key and sufficient credits.

Which Opus, Sonnet and Haiku models are listed?

The current site catalog and pricing page list these models:

Family	Models listed on ModelFold
Claude Opus	Opus 4.5, 4.6, 4.7, 4.8, 5 and 5.5
Claude Sonnet	Sonnet 4.5, 4.6, 5 and 5.5
Claude Haiku	Haiku 4.5 and 5.5
Claude Fable	Fable 5

Figure: Claude rows from the English pricing page; columns show model and input/output basis, credits, and US dollars per million tokens. Prices were captured on November 5, 2026; final charges follow usage settlement.

Start with a task from your own workflow: organizing requirements, explaining an error or reviewing a small piece of code. Compare whether each answer is useful on the same input, then consider the credit usage before choosing a model for regular work. This is a suggested evaluation method, not a performance ranking or a benchmark conducted for this article.

These are display names. When configuring Claude Code or an API request, use the model ID returned by the model-list endpoint rather than copying a display name into the request.

Stable and reliable: error detection, automatic refunds and credit settlement

ModelFold's Claude Code / Messages interface reserves credits before a request and settles the charge when it ends. Its existing handling detects API error events as well as empty results with no output tokens, content blocks or text deltas. These cases are treated as failures: the actual charge is zero and reserved credits are automatically refunded.

That provides a defined resolution when a request produces no result after a credit reservation. Successful requests also reconcile the reservation against the settlement amount rather than simply charging the initial estimate.

There is an important boundary: if content has already been produced before you cancel or the connection drops, actual usage may still be charged. An interrupted request is not necessarily free. This article does not promise that every request will succeed or turn these mechanisms into an unmeasured uptime claim.

Affordability starts with a manageable budget

ModelFold uses prepaid credits and usage-based billing, with no monthly subscription required. New registrations currently receive 50 credits, allowing you to try a small task before deciding whether to top up. The number of requests those credits cover depends on the model, input length and output volume.

Figure: The English homepage currently offers 50 free signup credits; check the live page for subsequent changes.

The current fixed top-up packages are denominated in US dollars:

Top-up amount	Credits received
$5	1,000
$20	4,000
$50	10,750
$500	110,000

The $5 and $20 packages both provide 200 credits per dollar. The $50 package provides 215 credits per dollar, and the $500 package provides 220. Choose around your expected usage; a better credit rate does not require buying more than you need.

Claude input and output usage are billed separately, and usage such as caching can also affect settlement. Billable requests are rounded up under the billing rules, with a minimum charge of one credit. A displayed per-million-token rate alone therefore does not determine the exact charge for a request. Plan around model pricing, actual request length and the final usage record.

The practical saving here is control over spending and the ability to evaluate with a small balance, rather than an unverified percentage discount.

Connect Claude Code / API without setting up your own proxy

ModelFold provides an Anthropic Messages-compatible interface and a Claude Code CLI integration guide. In your own environment, configure your ModelFold API key, set ANTHROPIC_BASE_URL to https://modelfold.ai/anthropic, and select a model ID from the model-list response.

The base URL ends at /anthropic; Claude Code appends the request path. Your own application can also use the corresponding Messages API. Follow the site's documentation for the configuration details.

Figure: Configuration examples from the English CLI guide show the base URL and credential variables; only variable names and example placeholders are visible, with no real credentials.

A practical first session is:

Register and check your signup credits and current model prices.
When you need programmatic access, create your own API key in your account and configure Claude Code or your application using the guide.
Read the available-model list, choose a model and submit a short task without sensitive information.
Review the answer and credit usage before expanding the input, changing models or adding funds.

ModelFold pricing · Claude Code CLI integration guide

Designing an AI Livestream Assistant: Separate Scripts from Generated Replies

ModelFild — Mon, 02 Nov 2026 15:34:11 +0000

A welcome message and an answer to a viewer's question do not need the same execution path. A welcome can use a preset. A contextual answer may need a model.

ModelFold AI Live Room 0.1.0 uses both paths in a desktop app: it reads Douyin livestream chat, generates spoken replies, and drives a Live2D avatar's mouth movement from voice volume.

Disclosure: this is a ModelFold team walkthrough based on the public setup guide and implementation. We did not conduct a new live broadcast or paid reply test for this article. It contains no latency, conversion, or audience-growth benchmark.

The platform boundary comes first

The app's documented chat integration is Douyin, not TikTok, Twitch, or YouTube. An English interface is available, but that does not establish an integration with English-speaking streaming platforms. OBS capture and chat collection are also different things: being able to capture a window does not add another platform's chat API.

Installers are available for Apple silicon Macs, Intel Macs, and Windows x64 through the setup guide. They are unsigned and not notarized; evaluate that before installation and follow the guide if your operating system blocks them.

Separate the speech paths

The app supports preset welcomes, grouped welcomes, and preset idle introductions. These paths do not call a language model. Contextual chat replies use a configured persona and recent conversation context, with duplicate filtering and reply queues.

Here is an illustrative event-routing sketch, not an app configuration file or a claim of its exact scheduler:

// Architecture sketch only; these function names are not an SDK.
function chooseSpeechPath(event) {
  switch (event.type) {
    case 'viewer_join':
      return { path: 'preset_welcome', needsLLM: false };
    case 'idle_interval':
      return { path: 'preset_intro', needsLLM: false };
    case 'viewer_question':
      return { path: 'contextual_reply', needsLLM: true };
    default:
      return { path: 'no_reply', needsLLM: false };
  }
}

This separation makes the cost boundary understandable: the desktop app is free, while AI replies use ModelFold account credits based on actual model usage. Presets do not consume language-model credits. Network, hardware, or platform costs are separate, and speech synthesis depends on a network service.

Rehearse before connecting a live room

Start with mock chat and offline scripts. Use a persona with a defined scope. The following is a sample persona brief to adapt, not a built-in default:

Role: a supervised host for a software demo.
Answer briefly using only the supplied product facts.
If pricing, availability, or a claim is uncertain, ask the human host.
Do not invent offers, customer stories, or platform policies.

A prompt is guidance, not a safety guarantee. Keep a person supervising and able to take over.

Try a short rehearsal matrix:

Input	What to inspect
Several viewers arrive close together	Grouped welcomes and speech pacing
The same question appears twice	Duplicate filtering and queued replies
Chat becomes quiet	Preset idle introduction
A question is outside the persona's facts	Whether a human needs to intervene

The first stages can be rehearsed without a model call. Testing generated answers is a separate, credit-consuming step.

Treat video and audio capture as a separate check

The app offers Live2D lip sync, backgrounds, captions, aspect ratios, and output settings for use with OBS or a livestreaming companion. Add the avatar source or capture its window, configure audio, and inspect the actual capture in your environment. Do not infer universal OBS compatibility from the presence of an output setting.

Before a public stream, check audio routing, visible captions, required AI or virtual-host labeling, and the human takeover procedure. Use a room you are authorized to connect and assets whose licenses cover your use. The bundled Live2D sample is a demonstration asset, not a blanket commercial license.

Keep unfinished features out of the promise

Gift decoding and priority queuing exist, but real gift events still need validation. Likes can be collected; dedicated reply scripts are planned. Printer connections and automatic printing are not implemented.

The public feature-status page is the useful starting point if this Douyin-specific workflow fits your project. A reliable rehearsal should establish what your setup can actually do before you promise it to viewers.

Render Personalized Images from One Editable Template with ModelFold Studio

ModelFild — Mon, 02 Nov 2026 15:33:15 +0000

If the layout is already approved and only the speaker name or session title changes, you can fill a template instead of asking an image model to recreate the design for every record.

ModelFold Studio exposes a rendering endpoint for that workflow: one editable document, an array of variable values, and one output image per row.

Disclosure: this is a ModelFold team tutorial. Requests below are illustrative and have not been submitted as paid renders for this article. Sample names and sessions are fictional input data, not customer examples.

Prepare the template first

Open Studio and prepare your own template with text placeholders such as {{name}} and {{session}}. Save it as a template in your account. The API lists your templates and their detected variables:

# Assumes MODELFOLD_API_KEY is set privately in your shell.
curl -sS 'https://modelfold.ai/v1/studio/templates' \
  -H "Authorization: Bearer $MODELFOLD_API_KEY"

Use an ID returned for your own account, not a public gallery slug or the example number from another guide. Inspect its variables, width, and height before building a batch.

Text placeholders are replaced by matching row values. A missing value becomes an empty string, so validate your data before rendering. A long session title may need a different layout: substitution is not a guarantee that arbitrary text fits.

Submit a small batch

Create render-request.json, replacing YOUR_TEMPLATE_ID with your own returned ID:

{
  "template_id": "YOUR_TEMPLATE_ID",
  "rows": [
    {"name": "Alex", "session": "Shipping a Small API"},
    {"name": "Sam", "session": "Designing Useful Defaults"}
  ],
  "page": 0,
  "format": "png",
  "scale": 1
}

Then submit it when you are ready to spend render credits:

curl -sS 'https://modelfold.ai/v1/studio/render' \
  -H "Authorization: Bearer $MODELFOLD_API_KEY" \
  -H 'Content-Type: application/json' \
  --data-binary @render-request.json > render-response.json

This endpoint is synchronous. It is different from the async task API used for generating complete PPT decks. A render request accepts up to 100 rows and selects one zero-based page. It supports PNG or JPG and a scale from 0.25 to 2. For a single output, use variables instead of a batch of rows.

Inspect every row result

A successful HTTP response does not mean every image rendered. The response's results array contains per-row success flags and either a URL or an error. With jq installed:

# Print successful image URLs.
jq -r '.results[] | select(.ok == true) | .url' render-response.json

# Inspect failures before deciding what to retry.
jq '.results[] | select(.ok != true)' render-response.json

# Read the final charge reported for the batch.
jq '.credits' render-response.json

Preserve the input row order alongside the result array so you can identify failed records. The documented default is one credit per successful image; pricing is configurable. The implementation reserves for the requested batch, then settles against successful renders. Failed images are not charged.

Do not apply the deck-creation API's idempotency promise to /v1/studio/render: this render endpoint does not document an Idempotency-Key guarantee. If a client times out after submission, check account usage before blindly resending the batch.

Where AI and PPT fit

This API renders an existing Studio document. There is currently no public endpoint for generating a single design from a text prompt. You can start a design in the Studio interface and reuse its layout with data.

For a complete presentation, ModelFold PPT 1.1 uses the async jobs API and can return a deck for further editing in Studio. PPTX exports aim to preserve editable text and supported shapes; some other elements are rasterized. That is a separate workflow from rendering one selected page per data row.

See the Studio API reference for rendering and the PPT model reference for deck generation. Test one representative row, then a long-text row, before scaling up.

Claude Desktop vs Claude Code CLI: Two Different Gateway Setups

ModelFild — Mon, 02 Nov 2026 15:32:05 +0000

Changing a terminal environment variable can route Claude Code CLI through a gateway. It does not configure the Code tab inside the Claude desktop app. Those are separate configuration paths, and confusing them can leave you using the wrong account.

Disclosure: this tutorial comes from the ModelFold team. It uses our gateway as the example. The Windows screenshots document configuration and the Gateway state; they are not evidence of a completed paid coding session.

Choose the right surface

This guide covers the desktop app's Code tab and the CLI. It does not add third-party API keys to ordinary claude.ai web chat or the mobile app.

For the desktop app, use the third-party inference form. For the CLI, use environment variables. ModelFold's Windows walkthrough now includes real screenshots of the relevant menus.

Configure the desktop app on Windows

Install the official Claude desktop app using the download link in the walkthrough. You will also need your own ModelFold API key from Console → API Keys.

Open the application menu at the top left.
Choose Help → Troubleshooting → Enable Developer Mode. Let the app restart.
Open Developer → Configure Third-Party Inference.
Under Connection, choose Gateway and enter:

Inference provider: Gateway
Gateway base URL: https://modelfold.ai/anthropic
Credential kind: Static API key
Gateway API key: <your raw mf- key>
Gateway auth scheme: bearer

Click Apply Changes and allow the app to relaunch. Follow a Save & Restart prompt if it appears. These are application settings; putting the same information in a terminal does not configure this desktop surface.

The screenshot uses a Chinese application UI. The field values above provide the English equivalents.

Keep the base URL at /anthropic. The client appends /v1/messages; adding /v1 yourself can produce an incorrect path. Paste the key without Bearer because the selected authentication scheme adds that prefix.

After restarting, the Code page should identify the connection as Gateway. This checks the selected configuration, not whether every model request will succeed.

Configure the CLI separately

If you use Claude Code in a terminal, the configuration is different. The following PowerShell example assumes you have already set MODELFOLD_API_KEY privately in that shell. Do not paste a real key into an article, repository, or screenshot.

# These variables affect the CLI launched from this PowerShell session.
$env:ANTHROPIC_BASE_URL = "https://modelfold.ai/anthropic"
$env:ANTHROPIC_AUTH_TOKEN = $env:MODELFOLD_API_KEY

# Read-only model discovery; this does not generate an answer.
curl.exe -sS "https://modelfold.ai/anthropic/v1/models" `
  -H "Authorization: Bearer $env:MODELFOLD_API_KEY"

# Use an actual id returned above, not a guessed model alias.
claude --model "<model-id-from-the-response>"

Replace the model placeholder before running the final command. Prefer one credential method; an old ANTHROPIC_API_KEY in your environment can make the configuration harder to reason about. In the CLI, /status helps check the base URL and authentication source. PowerShell users should use curl.exe, since curl may resolve to a PowerShell alias.

Separate configuration checks from paid tests

A models response confirms discovery and authentication. The Gateway label confirms the desktop configuration. Neither proves a completed generation.

When you decide to test a real coding request, use a small local folder and a short task, review the requested file/tool permissions, and check the usage record in your ModelFold account afterward. Generation consumes credits; this article did not run a paid desktop request.

If you see 401, check for a revoked key or a duplicated Bearer prefix. For 404, check the base path. A Windows Virtual Machine Platform warning is a separate workspace prerequisite, covered in the Windows walkthrough. Organization-managed settings may prevent local changes.

Anthropic documents the desktop gateway configuration in its gateway reference and in-app configuration guide. Use those for client changes; use the ModelFold CLI guide for our endpoint and authentication details. Do not assume cloud sessions or ordinary chat use this local configuration.

Introducing ModelFold Studio: From an Idea to an Editable Poster or Slide Deck

ModelFild — Fri, 30 Oct 2026 12:25:04 +0000

You have the outline for a presentation, but the first slide is still blank. Or an event is coming up and you need a poster today. Getting to a usable first draft can take longer than expected.

We built ModelFold Studio to help with that step. Start with a template or describe what you need, then keep working on the text and layout in the editor. Studio supports individual designs and complete slide decks.

This is a walkthrough of our own product. The screenshots show the Chinese interface used in our hands-on test; the English text below explains the same workflow. The example edits and exports were made from a template, without paid AI generation.

Start with a template and make it yours

Open the template gallery, choose a design, and sign in to create your own editable copy.

For a quarterly review, the business presentation template gives you a starting layout. Replace the title, reporting period, and key points, then adjust the placement of individual elements.

In our test, we opened this template in the editor, selected the main title in the layer panel, and changed it to the Chinese equivalent of “Q4 Business Review.” We also updated the subtitle to describe the team's results and next steps. Changes save automatically.

The layer panel helps you select the element you want. The canvas shows the design, and the properties panel lets you change its text and appearance.

Preparing a product announcement instead? The product launch template offers another starting point.

Describe the first draft you need

When you want to start from a prompt, give Studio the audience, format, required content, and visual direction. For example:

Create a portrait opening-week poster for Mountain Coffee. Use warm cream and coffee-brown colors with a clean, welcoming layout. Make “Opening Week: Second Drink Half Price” the headline. Include November 1–7 and the sample address 18 Example Street. The design will be used as an Instagram feed post.

Choose an appropriate canvas size, enter the brief, and generate a draft. Pick a result and continue editing it: refine the headline, correct the offer details, or move an element to improve the layout.

The same approach works for posters, social media covers, infographics, and individual presentation pages. Custom canvas dimensions are available when you have a specific size requirement.

For a full deck, review the outline first

Switch to the full slide deck mode, enter your topic, and choose the slide count, language, and visual theme. Generate an outline before creating the pages.

This gives you a chance to review slide titles, key points, and order while changes are still quick to make. For an employee onboarding deck, for example, check that the outline covers the team, everyday workflows, and common questions before generating the slides.

Once the pages are ready, continue editing them individually and use presentation mode to preview the flow. Review the story before polishing the visual details.

Export for the next step

Studio offers PNG, JPG, PDF, and PPTX exports, plus a PNG ZIP option for multi-page designs.

We downloaded both PNG and PPTX files during the template walkthrough. Here is the exported PNG after changing the title and subtitle:

For PPTX exports, Studio aims to preserve text, solid-color shapes, and lines as editable objects. Some other elements are rendered as images, so check the exported file in your presentation software if you plan to keep editing it.

You can also enable public sharing when you want someone to view a design online. Public sharing provides a read-only view.

Try it with one real task

Start with the next thing you actually need: an event poster, a project update, or a cover for your next post. A useful brief answers four questions: who will see it, where it will appear, what it must say, and how it should feel.

Open ModelFold Studio, choose a template or write a brief, and turn the first draft into something you can use.

AI generation uses credits; check the estimate shown in the interface. Review generated text, figures, and factual claims before publishing or presenting your work.

Getting Started with Kling 4.0 on ModelFold: Reference Inputs, Keyframes, and a Real Video Example

ModelFild — Thu, 29 Oct 2026 13:08:04 +0000

An animated image is a useful starting point. For a more deliberate video, the questions become more specific: Can I use my own product photo? Can a reference clip guide the camera movement? Can I decide how the shot begins and ends?

This guide walks through the two Kling 4.0 modes currently available through ModelFold: Reference to Video and Keyframe to Video. It includes the actual input images and an existing output example, followed by a simple workflow for your first clip.

Disclosure: I work on ModelFold, which provides access through an upstream provider. This is a guide to our current integration, rather than an independent benchmark. The example below was already available on our model page; I did not run a new generation for this article.

What is available today?

ModelFold currently offers 720p and 1080p output, durations from 3 to 30 seconds, and synchronized audio and video generation. Plan around the options currently available on the model page: 4K and HDR are marked as upcoming there.

Kling 4.0 is developed by Kuaishou. This article introduces access through ModelFold; it does not claim an exclusive launch or access ahead of the official release. For the developer's own overview, see Kling AI's production examples.

The practical choice is how you want to guide a shot.

Reference to Video: give each input a clear role

Use this mode when existing images or video should inform the result.

For example, the prefilled example on our model page uses a reference video to guide camera movement and pacing, with separate images for a car and its background. The useful idea is to separate the roles of the inputs before writing the prompt:

Subject: what object or character should appear?
Setting: where should the action happen?
Camera: what movement and pacing should the clip follow?

Explain those roles in the prompt. A collection of references gives the model more material, but clear instructions are still needed to say how the pieces belong together.

Keyframe to Video: decide the beginning and ending

Use this mode when the composition at particular points matters most. It supports a first frame, intermediate frames, and a final frame.

The maximum is 10 keyframes, but the limit also depends on clip duration. For example, a five-second clip supports up to six frames; the full 10-frame allowance starts at nine seconds. Check the duration-specific limit before preparing a large set of images.

One useful application is a process with a clear beginning and result. The existing blacksmith example illustrates this approach.

A real input-to-output example: iron stock to a finished sword

These two images and the video are paired together in ModelFold's existing Keyframe to Video example. They were not selected from unrelated assets.

First frame: five pieces of iron on a workbench.

Final frame: the finished sword on the workbench.

Output: an approximately 15-second blacksmithing sequence.

Watch the existing generated video, or open the Kling 4.0 model page to view the paired example.

The example prompt divides the process into stages: collecting the material, heating, forging, grinding, assembly, and placing the finished sword. It asks for one blacksmith throughout, a consistent workbench setting, and compositions that match the opening and closing images.

Those are prompt goals. When reviewing the result, compare the starting and ending compositions, then inspect the transitions and action continuity. Do not assume that every requested physical detail has been reproduced accurately.

The linked preview is the original display file: approximately 15 seconds at 850 × 480, with an audio track. Its dimensions describe that preview asset, not the selectable resolution for a new generation.

Your first clip: a simple workflow

Open the ModelFold Kling 4.0 page and sign in or register. You can use the web Playground directly; create an API key only if you need programmatic access.
Choose Reference to Video for a shot guided by existing visual references, or Keyframe to Video when you want to specify the opening and ending images. Look at the paired input and output example first.
Begin with 720p and three or five seconds. Keep the subject, action, and camera movement simple so the result is easier to assess.
Replace the prefilled example materials. Remove any images, videos, and prompt references that do not belong in your own clip.
Review the settings and displayed cost before running the task. Inspect the result before increasing duration or resolution.

A small starting prompt could be:

A ceramic mug sits on a wooden table. The camera slowly moves closer. Soft daylight enters through a nearby window. Quiet indoor ambience.

This is a suggested prompt, not a tested output from this article. Change one part at a time so you can tell which adjustment helped.

When to use the API

The Playground is a convenient place to inspect examples and explore basic settings. Some complex nested parameters for subjects and voices are not fully exposed in the current web form. If you need those controls, consult the API documentation for the selected mode.

For a product clip, storyboard preview, or image-to-video experiment, start with one clearly defined shot. Decide what your references control, keep the first attempt short, and evaluate the output before building a longer sequence.

Explore Kling 4.0 on ModelFold

Turn One Photo into a Vertical AI Video: A Practical Template Workflow

ModelFild — Sun, 25 Oct 2026 17:59:21 +0000

You have a good photo and an idea for a short video. What you probably do not have is a shot list, a folder of matching clips, or the patience to write a different prompt for every cut.

A template can handle that planning. You choose the scene, supply the subject, review the cost, and let the workflow build the shots and join them into a vertical film.

Disclosure: I build ModelFold, the product used in this walkthrough. This is a guide to its current workflow, not a comparison based on testing competing tools. The examples are existing template previews; I did not run a new paid generation for this article.

Start with the result you want

Open the AI Short Video tool and look through the template previews. A preview shows the intended scene and style. It is not a prediction of exactly how your photo will turn out.

For a simple first project, try one of these:

Pet marigold bridge: a quiet, 10-second memorial with two shots, warm mist, petals, and candlelight. The name references the rainbow bridge idea, but the actual scene uses a marigold-covered bridge.
Pet chef: a playful kitchen scene built around a pet photo.

Choose a scene that suits the photo you already have. A pet template needs a clear pet reference; a portrait effect needs a face the model can actually see.

1. Prepare one clear reference image

Use a JPG, PNG, or WebP file up to 3MB. Prefer one obvious subject, good lighting, and minimal obstruction. If you want the model to preserve a pet's markings, make sure those markings are visible.

Leave a little space around the subject. A tight landscape crop can be awkward to reinterpret as a 9:16 frame. Only upload photos you have permission to use, especially when they show another person.

The same uploaded image serves as the reference for the template's shots. You do not need a separate upload for each scene. That shared reference helps guide consistency, but AI can still change facial features, fur patterns, or proportions.

2. Read the shot list before generating

Open a template and sign in. Upload the image, then read the shots and model settings on the page.

For the memorial template, the first shot has the pet walking toward the camera across the bridge. The second has it pause and look back. Together they make a 10-second vertical video. The configured workflow creates the still frames with Seedream 5.0 Flash and animates them with Wan 2.6 Flash at 720p.

Templates have fixed creative choices. This one does not add a spoken tribute or captions. If you want a name and dates, add them to the downloaded video in an editor.

Read product templates especially carefully. A scene that asks for an unbranded object and no text is a poor choice if your packaging label must stay legible. A visually attractive preview does not establish that a template can preserve a logo.

3. Check the estimate and confirm

Opening the page, watching a preview, and selecting a template do not spend generation credits. Generating your video does.

Check the estimated credits on the page and again in the confirmation dialog. Prices depend on the configured image and video steps, so use the current estimate rather than a number copied from an old tutorial.

The fixed template already includes its shot plan; you do not first pay to generate alternative plans. Each generation step is charged separately. Failed steps are refunded, while successful steps remain charged. Retrying a step is a new generation and can incur another charge.

4. Let the workflow assemble the film

The progress panel lists the still images, video clips, and final joining step. You do not have to download each shot and stitch them together yourself.

Once a result is ready, the player switches from the example to your film. Review the subject carefully before using it: does your pet still look like your pet? Are movement and proportions plausible? Does the scene communicate what you intended?

If only part of a run succeeds, the finished portion may be available and the failed steps refunded. Check the status rather than assuming that a playable result means every shot succeeded.

5. Download, then finish it for your audience

Download the MP4. Signed-in history on the tool page also lets you revisit the run, its steps, and its download.

For a memorial, a simple title may be enough. For a social post, you may want captions or a short opening line. Add those deliberately in your editor rather than relying on generated text inside the image.

ModelFold does not automatically post the file to another platform. Download it, review it, and upload it yourself. Follow the destination platform's rules for disclosing AI-generated content.

What if no template fits?

The same tool has a free-form route. Describe the film, set the duration and shot count if needed, and request plans. For example:

A 15-second vertical video with three shots of a white travel mug: a full view, a close-up of the lid, then the mug on a commuter's desk. Natural light and restrained camera movement.

Review the proposed plans, models, and estimates before executing one. Planning uses a conversation model and has its own charge; generating the images and clips is a separate stage. It gives you more flexibility, with more decisions to make.

For a first attempt, a fixed template keeps those decisions manageable: choose the scene, upload a suitable photo, read the estimate, generate, and inspect the download.

You can browse the examples at ModelFold before deciding whether the workflow fits your project.