Models

In the 데브다이브-모두의창업 AI API, a model means "a single AI that's good at a particular job." There are models good at writing, models that create voices, models that draw pictures — each has its own specialty.

To get a job done, you choose the model that fits the job by its model ID. Every model ID starts with modoo- (for example, modoo-text, modoo-image-z).

Curious which models are available right now?

Call GET /v1/models and you'll get the list of available models all at once.

curl https://modoo.devdive.me/v1/models \
  -H "Authorization: Bearer sk-modoo-..."

Inside the response's data, you'll find each model's id (the name we choose).

The 3 call kinds (be sure to understand these before moving on)

Each model has a different way of returning its answer. There are three main kinds.

Synchronous (answer comes right away): when you send a request, the result comes back in that same response. This covers relatively quick tasks like writing, text-to-speech, and image/document analysis.
Streaming (text arrives in real time): instead of waiting for the answer to be finished, the text arrives bit by bit in real time as the AI writes it. This is great when you want a "typing" feel, like in a chat window. You can turn it on with stream: true on text models.
Asynchronous (takes time, check later): for time-consuming tasks like image/video generation or speech recognition, the result isn't returned right away. Instead, you first receive a job number (job_id). Later, you use that number to ask "is it done yet?" (polling) and get the finished result.

Asynchronous tasks need "checking in" (polling)

If you receive a job_id, check its status with GET /v1/jobs/{job_id}. For details, see the polling guide in the API Reference.

Which AI is each model, really? (mapping)

A modoo- model ID is an alias that wraps a specific provider's model. The current mapping is as follows.

Model ID	Actual model (as of today)
`modoo-text`	OpenAI GPT-5.1
`modoo-text-pro`	OpenAI GPT-5.4
`modoo-text-mini`	OpenAI GPT-5 mini
`modoo-text-nano`	OpenAI GPT-5 nano
`modoo-text-pro-mini`	OpenAI GPT-5.4 mini
`modoo-text-pro-nano`	OpenAI GPT-5.4 nano
`modoo-text-4o`	OpenAI GPT-4o
`modoo-claude-opus`	Anthropic Claude Opus 4.6
`modoo-claude-sonnet`	Anthropic Claude Sonnet 4.6
`modoo-claude-haiku`	Anthropic Claude Haiku 4.5
`modoo-tts-minimax`	MiniMax TTS
`modoo-tts-eleven`	ElevenLabs TTS
`modoo-stt`	Whisper
`modoo-music`	MiniMax Music
`modoo-image-z`	Z-Image Turbo
`modoo-image-gpt`	GPT Image 2
`modoo-image-edit`	Qwen Image Edit Plus
`modoo-image-edit-max`	Qwen Image Edit Max
`modoo-image-gpt-edit`	GPT Image 2 (image-to-image)
`modoo-video`	WAN 2.7 (text-to-video)
`modoo-video-i2v`	WAN 2.7 (image-to-video)
`modoo-video-happyhorse-t2v`	HappyHorse 1.1 (text-to-video)
`modoo-video-happyhorse-i2v`	HappyHorse 1.1 (image-to-video)
`modoo-video-happyhorse-r2v`	HappyHorse 1.1 (reference-to-video)
`modoo-web-search`	Brave Search

Mappings can be upgraded without notice

The whole point of aliases is to let us upgrade you to better models without you changing a line of code. Don't build logic that depends on a specific version — the request/response format stays the same.

Text models

These are models that handle "words and text" — writing, summarizing, translating, organizing ideas, and so on. They all use the same endpoint (POST /v1/chat/completions) and support both synchronous and streaming. In other words, the models below are interchangeable — just swap them in and out.

Model ID	Description	Call kind / Endpoint	RPM
`modoo-text`	General-purpose default. Solid for most tasks	Synchronous & streaming · `POST /v1/chat/completions`	15,000
`modoo-text-pro`	The smartest. For hard, long tasks	Synchronous & streaming · `POST /v1/chat/completions`	15,000
`modoo-text-mini`	Fast and inexpensive	Synchronous & streaming · `POST /v1/chat/completions`	30,000
`modoo-text-nano`	Ultra-light, lowest cost, for simple tasks	Synchronous & streaming · `POST /v1/chat/completions`	30,000
`modoo-text-pro-mini`	Fast, inexpensive 5.4 series	Synchronous & streaming · `POST /v1/chat/completions`	30,000
`modoo-text-pro-nano`	Ultra-light 5.4 series	Synchronous & streaming · `POST /v1/chat/completions`	30,000
`modoo-text-4o`	General-purpose (for compatibility)	Synchronous & streaming · `POST /v1/chat/completions`	15,000
`modoo-claude-opus`	Claude's top tier, for complex reasoning	Synchronous & streaming · `POST /v1/chat/completions`	20,000
`modoo-claude-sonnet`	Claude, balanced	Synchronous & streaming · `POST /v1/chat/completions`	20,000
`modoo-claude-haiku`	Claude, lightweight and fast	Synchronous & streaming · `POST /v1/chat/completions`	20,000

Text models are fully interchangeable

In the examples below, only the model value differs — everything else is the same. If you just need a quick answer, pick modoo-text-mini; for a hard task, swap in modoo-text-pro or modoo-claude-opus.

Example 1 — get a quick answer with the default model. This request asks it to come up with "3 cozy cafe names that suit autumn."

curl https://modoo.devdive.me/v1/chat/completions \
  -H "Authorization: Bearer sk-modoo-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "modoo-text",
    "prompt": "Come up with just 3 warm, evocative cafe names that suit autumn."
  }'

The names the AI came up with are in the response's content. cost is the credits deducted by this call.

Example 2 — switch to a smarter model. Just change model to modoo-text-pro. This request hands it a tougher business idea analysis.

curl https://modoo.devdive.me/v1/chat/completions \
  -H "Authorization: Bearer sk-modoo-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "modoo-text-pro",
    "prompt": "Summarize the strengths and weaknesses of the following business idea, three each: a neighborhood side-dish subscription service"
  }'

Example 3 — a fast, inexpensive model. For a simple task, modoo-text-mini is plenty.

curl https://modoo.devdive.me/v1/chat/completions \
  -H "Authorization: Bearer sk-modoo-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "modoo-text-mini",
    "prompt": "Rewrite this sentence in polite, formal language: what time is tomorrow'\''s meeting?"
  }'

In all three examples, you look in the same place in the response — content (the AI's answer), usage (the number of tokens used), and cost (the credits deducted).

To make the text appear in real time

Add "stream": true to the request body and the answer will arrive one character at a time, in real time. For the detailed format, see the API Reference.

Audio models

These are models that create a voice (TTS, text-to-speech) or turn speech into text (STT, speech recognition).

Model ID	Description	Call kind / Endpoint	RPM
`modoo-tts-minimax`	Text-to-speech (TTS) — turn text into a human voice	Synchronous · `POST /v1/audio/speech`	60
`modoo-tts-eleven`	Text-to-speech (TTS)	Synchronous · `POST /v1/tasks/modoo-tts-eleven`	60 (5 concurrent)
`modoo-stt`	Speech-to-text (STT) — turn a voice into text	Asynchronous · `POST /v1/audio/transcriptions`	60
`modoo-music`	Music generation — turn lyrics into a song	Asynchronous · `POST /v1/audio/music`	120 (20 concurrent)

An easy way to remember: TTS is "text → voice," and STT is "voice → text." Music generation (modoo-music) turns lyrics and a style into a full song (see Music generation below).

Example (synchronous) — turn text into a voice. This request creates an audio file that reads out the sentence.

curl https://modoo.devdive.me/v1/audio/speech \
  -H "Authorization: Bearer sk-modoo-..." \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Hello, this is 데브다이브-모두의창업. Have a great day!"
  }'

The response's result.audio_url is the address of the finished audio file. charge is the credits deducted.

Speech recognition (STT) is asynchronous

When you send an audio file to POST /v1/audio/transcriptions, the result doesn't come back right away — you get a job_id instead. Poll with that number to receive the transcribed text.

curl https://modoo.devdive.me/v1/audio/transcriptions \
  -H "Authorization: Bearer sk-modoo-..." \
  -F "[email protected]" \
  -F "language=ko"

The response comes back with a job_id and status: "processing" → once it's done, the transcribed text is in the result.

Image & document analysis models

These are models you show a photo or document file to, and they describe or summarize "what's in it." They're all synchronous, so the result comes back right away.

Model ID	Description	Call kind / Endpoint	RPM
`modoo-image-analyze`	Image analysis (description/questions)	Synchronous · `POST /v1/images/analyses`	600
`modoo-docs-analyze`	Document analysis (summarization, etc.)	Synchronous · `POST /v1/documents/analyses`	600

Example (synchronous) — get a document summarized. This request automatically summarizes the document you upload.

curl https://modoo.devdive.me/v1/documents/analyses \
  -H "Authorization: Bearer sk-modoo-..." \
  -F "[email protected]" \
  -F "operation=summary"

The summarized text is in the response's result.content. Image analysis (/v1/images/analyses) works the same way — check result.content for the description.

If the file is already online instead of on your computer, you can put -F "url=https://..." in place of -F "file=@...".

Web search model

A model that fetches live internet search results when you need up-to-date information. It's synchronous, so the result comes back right away.

Model ID	Description	Call kind / Endpoint	RPM
`modoo-web-search`	Web search — get fresh search results for a query	Synchronous · `POST /v1/tasks/modoo-web-search`	—

Example (synchronous) — search the web. Put your search terms in query.

curl https://modoo.devdive.me/v1/tasks/modoo-web-search \
  -H "Authorization: Bearer sk-modoo-..." \
  -H "Content-Type: application/json" \
  -d '{ "query": "latest small-business policy fund announcements" }'

The search results are in the response's result. A great combo is feeding the results into a text model to produce an "answer grounded in fresh information."

Image generation models

These are models that draw a picture when you describe it in words. Pictures take time to create, so they're all asynchronous (you first get a job_id, and when it's done you get the picture's address).

Model ID	Description	Call kind / Endpoint	RPM
`modoo-image-z`	Default, fast. `size` can be specified (`width*height`)	Asynchronous · `POST /v1/images/generations`	120
`modoo-image-gpt`	Generate multiple images with `n` (1–10). `size` is `auto`/`1024x1024`/`1536x1024`/`1024x1536`	Asynchronous · `POST /v1/images/generations`	5
`modoo-image-edit`	Image editing (image-to-image) — send an original image and describe the change (Qwen)	Asynchronous · `POST /v1/images/generations`	120
`modoo-image-edit-max`	Higher-quality image editing (much lower rate limit)	Asynchronous · `POST /v1/images/generations`	2
`modoo-image-gpt-edit`	Image editing (image-to-image) — GPT Image 2. Pass the original via `image_url` or `encoded_image` (base64); use `image_urls` for up to 3 references	Asynchronous · `POST /v1/images/generations`	5

Example (asynchronous) — create a picture. This request hands off the scene you described to be drawn as a picture.

curl https://modoo.devdive.me/v1/images/generations \
  -H "Authorization: Bearer sk-modoo-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "modoo-image-z",
    "prompt": "A cozy neighborhood cafe with warm lighting, autumn foliage outside the window",
    "size": "1024*1024"
  }'

size notation differs per model family

modoo-image-z and the Qwen edit models use an asterisk (1024*1024); modoo-image-gpt and modoo-image-gpt-edit use x (1024x1024). See the API reference for the full per-model list. Any other value returns a 422.

You get a response like this right away — a job_id and status: "processing".

{ "job_id": "job_abc123", "status": "processing", "model": "modoo-image-z", "charge": 1.2 }

Now check the result with the job_id you received (poll).

curl https://modoo.devdive.me/v1/jobs/job_abc123 \
  -H "Authorization: Bearer sk-modoo-..."

When it's done (status: "succeeded"), the addresses of the finished pictures are in result.image_urls.

Example — edit an existing image (image-to-image). When you want to keep an image you already have and change it (same person, different background, etc.), send the original image to modoo-image-edit. Pass the original as either image_url (a web address) or encoded_image (base64).

curl https://modoo.devdive.me/v1/images/generations \
  -H "Authorization: Bearer sk-modoo-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "modoo-image-edit",
    "prompt": "Keep the same person, change only the background to a city at night",
    "image_url": "https://example.com/photo.jpg"
  }'

The response and polling work the same as above (you get a job_id). Plain generation models like modoo-image-z do not take a reference image — use modoo-image-edit (or -max) whenever the original must be preserved.

To edit with GPT Image 2, use modoo-image-gpt-edit. Just like modoo-image-edit, pass the original as either image_url (a web address) or encoded_image (base64). For multiple references (up to 3), use the image_urls array:

curl https://modoo.devdive.me/v1/images/generations \
  -H "Authorization: Bearer sk-modoo-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "modoo-image-gpt-edit",
    "prompt": "Keep the same person; change the background to a night cityscape",
    "image_url": "https://example.com/photo.jpg"
  }'

Picture and video addresses expire if left too long

Media addresses expire over time. Rather than saving the link somewhere, look it up again with the job_id when you need it to get the latest address.

Video generation models

These are models that create a short video when you describe it in words. This also takes time, so it's asynchronous.

Model ID	Description	Call kind / Endpoint	RPM
`modoo-video`	Text→video. `prompt` (+`negative_prompt`)	Asynchronous · `POST /v1/videos/generations`	300
`modoo-video-i2v`	Image→video — animate an image you have as the first frame	Asynchronous · `POST /v1/videos/generations`	300
`modoo-video-happyhorse-t2v`	Text→video (HappyHorse 1.1). `prompt`	Asynchronous · `POST /v1/videos/generations`	300
`modoo-video-happyhorse-i2v`	Image→video (HappyHorse 1.1) — an image as the first frame	Asynchronous · `POST /v1/videos/generations`	300
`modoo-video-happyhorse-r2v`	Reference→video (HappyHorse 1.1) — 1–9 character reference images + `prompt`	Asynchronous · `POST /v1/videos/generations`	300

Example (asynchronous) — create a video. This request hands off the scene you described to be made into a short video.

curl https://modoo.devdive.me/v1/videos/generations \
  -H "Authorization: Bearer sk-modoo-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "modoo-video",
    "prompt": "A seaside at dusk with gentle waves rolling in",
    "negative_prompt": "people, text"
  }'

The response comes back with a job_id. Poll with that number and, once it's done, you can get the video's address from result.video_url.

negative_prompt is the field where you write "things you'd rather not see in the video" (in the example above, we asked to leave out people and text).

Example — turn an image into a video (image-to-video). To animate an image you already have as the first frame, send image_url to modoo-video-i2v. The image must be a reachable https address (base64 is not supported — the image_url from an image generation/edit result works as-is).

curl https://modoo.devdive.me/v1/videos/generations \
  -H "Authorization: Bearer sk-modoo-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "modoo-video-i2v",
    "prompt": "A timelapse where the sunset deepens and stars appear one by one",
    "image_url": "https://example.com/sunset.png"
  }'

First→last frame interpolation. With modoo-video-i2v (WAN 2.7), send end_image_url (the closing frame) alongside image_url (the opening frame) to produce a transition video that interpolates between the two. Both images must be https addresses.

curl https://modoo.devdive.me/v1/videos/generations \
  -H "Authorization: Bearer sk-modoo-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "modoo-video-i2v",
    "prompt": "A smooth transition from day to night",
    "image_url": "https://example.com/day.png",
    "end_image_url": "https://example.com/night.png"
  }'

Example — make a video from reference images (reference-to-video). modoo-video-happyhorse-r2v takes 1–9 character reference images as reference_image_urls (a list of reachable https addresses) and creates a video featuring that character.

curl https://modoo.devdive.me/v1/videos/generations \
  -H "Authorization: Bearer sk-modoo-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "modoo-video-happyhorse-r2v",
    "prompt": "The referenced character walking along a beach at sunset",
    "reference_image_urls": [
      "https://example.com/char1.png",
      "https://example.com/char2.png"
    ]
  }'

Video tuning options (WAN 2.7 · HappyHorse)

modoo-video (WAN 2.7) and the modoo-video-happyhorse-* models accept these optional knobs — resolution (720P·1080P), ratio (e.g. 16:9·9:16·1:1·4:3·3:4, t2v·r2v only — i2v preserves the input image's ratio), duration (integer), watermark (true/false), seed (integer). prompt_extend (true/false) is WAN 2.7 only. Each model ignores knobs it doesn't accept. For the full spec, see the API Reference.

Music generation

A model that creates a full song when you give it lyrics (and a desired mood). It takes time to create, so it's asynchronous (you first get a job_id, and when it's done you get the song file's address).

Model ID	Description	Call kind / Endpoint	RPM
`modoo-music`	Music generation — turn lyrics into a song	Asynchronous · `POST /v1/audio/music`	120 (20 concurrent)

Example (asynchronous) — make a song from lyrics. Put the lyrics in lyrics, and describe the mood/style in prompt.

The request's model is an engine version, not a model ID

There is one modoo model ID here — modoo-music (the table above, and the response's model field). The request body's model takes the upstream music engine version: music-2.5 (default) or music-2.0. This is the one endpoint where the rule differs.

curl https://modoo.devdive.me/v1/audio/music \
  -H "Authorization: Bearer sk-modoo-..." \
  -H "Content-Type: application/json" \
  -d '{
    "lyrics": "Autumn night alley, a warm cup of coffee\nYou did well today, to myself",
    "model": "music-2.5",
    "prompt": "A gentle acoustic ballad"
  }'

The response comes back with a job_id. Poll with that number and, once it's done, you can get the finished song file's address from result.audio_url.

How do I know what a call costs?

There is no fixed per-model price table. Cost is settled per call based on actual usage (token counts, generation volume, etc.), and that amount appears verbatim in the response's cost (or charge) field. That's exactly how many credits are deducted.

Credits remaining right now: GET /v1/credits
Per-model usage history and charges: GET /v1/usage

Run a small test before committing

Send a few requests that resemble your real workload with the model you plan to use, and check the cost in the responses. It's the most accurate way to learn "how many credits one of our tasks costs." Even on the same text model, cost varies with prompt/answer length (token count).

Call limits (rate limits)

If you send too many requests at once, a brief limit may kick in to keep the service stable. Don't be alarmed — just try again a little later.

Each model has an RPM (requests per minute) limit shown in the tables above.
Separately from that, there's a default per-API-key limit of 120/min and a default per-account limit of 3,000/min.
There's no daily total spending limit by default.

If you hit a limit (429)

Taking a short break and trying again usually resolves it. For detailed handling, see the rate_limited / daily_quota_exceeded entries in Troubleshooting errors.

The 3 call kinds (be sure to understand these before moving on)​

Which AI is each model, really? (mapping)​

Text models​

Audio models​

Image & document analysis models​

Web search model​

Image generation models​

Video generation models​

Music generation​

How do I know what a call costs?​

Call limits (rate limits)​