RunningHub Seedance 2.0 API Setup: Key, Assets, and First Call

AI Overview

What is the fastest way to set up the RunningHub Seedance 2.0 API?

Create a RunningHub API key, choose the exact Seedance 2.0 AI App or model route, send one minimal request, then poll its taskId. Add uploads, webhooks, and production retries only after that first call succeeds.

Should I use the AI App API or a ComfyUI workflow?

Use the AI App API when you want a fixed, hosted input contract. Use the ComfyUI OpenAPI route when your team needs visible node mappings, reusable graphs, asset preparation, or model steps that change between projects.

How do Seedance 2.0 asset IDs work in RunningHub?

Asset IDs let supported Seedance 2.0 nodes reuse prepared references. The ComfyUI integration accepts plain IDs, asset:// values, separated lists, or a JSON-array string, but the chosen node still determines valid input slots.

Why does a completed task URL need to be copied immediately?

RunningHub documents temporary media links for uploads and generated results. Move every approved MP4 and poster to your own durable storage as soon as the task succeeds; a stored task ID is not a permanent media archive.

What You Need Before Your First Call

A reliable setup begins with four known values: the API region, a valid key, the exact AI App or model identifier, and a storage destination you control. Do not copy an endpoint from an unrelated tutorial and assume its body is compatible. RunningHub exposes several call styles, and each published API detail page is the contract for that route. The broader Seedance 2.0 API guide explains the general asynchronous pattern; this guide stays focused on RunningHub.

Keep the key outside source control. For the official ComfyUI integration, the documented environment pattern is:

export RH_API_BASE_URL="https://www.runninghub.cn/openapi/v2"
export RH_API_KEY="replace-with-your-key"

Use the regional base URL shown in your own RunningHub console and current documentation. A consumer key may require an eligible membership, while enterprise keys can have different access rules. Treat the ability to see a model in the catalog and the ability to call it with your key as two separate checks.

Before spending credits, define one acceptance shot: one subject, one action, one camera move, one duration, and one delivery ratio. Test the creative brief in the Seedance 2.0 model workspace first if you are unsure whether the prompt itself is viable. That separates prompt problems from integration problems.

Use a visually simple acceptance frame for the first call. This fresh product image makes silhouette, reflections, water motion, and background stability easy to inspect; it is not a RunningHub benchmark.

Choose the Right RunningHub Route

RunningHub offers two practical paths for this task. The AI App route is useful when the provider has already packaged Seedance 2.0 into a stable application with named inputs. You submit to that app ID and receive a taskId. The ComfyUI OpenAPI plugin is better when the graph itself is part of your production logic or when you need its Seedance 2.0 asset helpers.

Do not combine the routes in your first test. A minimal AI App request should prove authentication, the app identifier, queue submission, and result retrieval. A minimal ComfyUI call should prove that the exported workflow runs unchanged before you introduce dynamic nodeInfoList overrides.

The official RunningHub ComfyUI plugin can read configuration from a settings node, environment variables, or a .env file, with node settings taking priority. Record which layer supplied the key. Otherwise a teammate can rotate the environment secret while an old node value continues to win silently.

A reference-heavy shot should keep the person, wardrobe, animal, weather, and location readable. The image is a fresh illustrative output, not an official model comparison.

RunningHub Seedance 2.0 API Setup Step by Step

Start with a request skeleton that exposes only variables your service truly owns. RunningHub's current AI App documentation shows an endpoint shaped like /run/ai-app/{appId} and returns a task object with states such as QUEUED, RUNNING, SUCCESS, or FAILED. Use the request example generated on the exact API detail page as the source of truth for field names.

const response = await fetch(`${RUNNINGHUB_BASE}/run/ai-app/${APP_ID}`, {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.RH_API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    nodeInfoList: inputMappings,
    webhookUrl: process.env.RH_WEBHOOK_URL
  })
});

if (!response.ok) throw new Error(`Submit failed: ${response.status}`);
const task = await response.json();

For a ComfyUI workflow, import one of the matching examples, connect RH OpenAPI Settings only if you are not using environment configuration, and run the graph with static values. After it works, expose only the nodes that need to vary—prompt, reference, duration, ratio, or output options—and store those node IDs beside the workflow version.

RunningHub's Seedance 2.0 asset tools add another choice. real_person_mode=false follows the direct-upload path. When enabled, selected local image or video slots can be converted to assets before the model request. conversion_slots controls which slots participate. Test one image first, because a nine-image, three-video payload hides which mapping caused a failure.

Vertical product orbit video for checking a retrieved API result

This playable Seedance motion output demonstrates what to inspect after retrieval: stable product geometry, a controlled camera move, and a clean frame. It is not presented as a RunningHub benchmark.

Build Inputs That Survive the API Boundary

The API cannot infer which file is a first frame, a final frame, a character reference, or a style reference. Create an input manifest before submission. Store a local name, source checksum, MIME type, intended slot, asset ID if created, and the prompt label that refers to it. This is more useful than a folder of files called final-2.png.

{
  "shot": "kitchen-01",
  "references": [
    {"role": "first_frame", "assetId": "asset-example-01"},
    {"role": "style", "url": "https://your-storage.example/style.jpg"}
  ],
  "prompt": "Medium tracking shot; chef plates the dish; steam rises; warm practical light",
  "ratio": "16:9"
}

The documented ComfyUI integration accepts one asset ID, an asset://<asset_ID> value, comma- or newline-separated values, or a JSON-array string. That flexibility is convenient, but consistency is safer: choose one representation in your codebase and validate it before the graph runs. For image-to-video, the integration identifies first_frame and last_frame; multimodal video nodes can expose multiple image and video slots. Use the reference-to-video workspace to refine a reference package before automating it.

Write prompts as executable shot instructions. Separate framing, subject, action, environment, light, and sound. If the first call fails creatively, simplify one channel rather than changing the endpoint, assets, prompt, and workflow simultaneously. The image-to-video prompt workflow provides a reusable prompt pattern.

This fresh finished frame demonstrates a test with readable hands, food geometry, steam, and practical lighting—four details worth checking across the generated clip.

Poll, Store, and Review the Result

After submission, persist the returned taskId before polling. Use exponential backoff with a ceiling, stop on terminal failure, and make polling idempotent so a restarted worker can continue the same job. If your route supports a webhook, verify its signature or shared secret before treating the payload as trusted. The callback should update the existing task record, not create a second generation.

On SUCCESS, copy the MP4 immediately. RunningHub states that generated result links and upload links can expire after 24 hours. Downloading only when a human opens a review screen is therefore unsafe. Store the file, checksum, provider task ID, prompt version, source manifest, and generation timestamp together. Then create a poster and a browser-playable proxy only if your delivery stack needs them.

Coffee and steam motion clip for reviewing subtle movement

This second real motion output uses restrained hand movement, rising steam, and sunlight, giving reviewers a different failure surface from the product orbit.

Review the complete clip, not only its first frame. Score identity, object geometry, motion continuity, camera path, background stability, audio fit, and delivery safety. A technically successful task can still be unusable. For campaigns with several models or providers, the multi-model AI video workflow shows how to preserve one review standard across routes.

Fabric direction, hand shape, foot contact, horizon stability, and camera height create a compact acceptance checklist for a motion-heavy result.

Fix Common RunningHub Seedance 2.0 API Errors

Treat errors by lifecycle stage. A 401 or 403 points to the key, region, membership, or permission—not the prompt. A request rejected before a taskId usually means the endpoint, app ID, content type, or body shape is wrong. A queued task that never advances is a queue or timeout problem. A FAILED task with content verification detail needs a safer prompt or reference. A successful task with an expired URL is a storage failure.

Log status code, provider error code, task ID, workflow version, and sanitized field names. Never log the API key or full private media URLs. Add an idempotency key in your own service even if the provider route does not expose one; it prevents a client retry from spending twice.

If the integration is technically working but coordination is becoming the bottleneck, use Seedance Agent to organize references, turn a brief into shots, compare approved outputs, and rerun only the failed stage. That is a production-layer choice, not a replacement for understanding the underlying API.

Conclusion

A durable RunningHub Seedance 2.0 API setup is a lifecycle, not a single successful cURL command: choose the correct AI App or ComfyUI route, keep the key outside code, prove one minimal call, map assets explicitly, persist the taskId, back off while polling, copy temporary results immediately, and judge the full clip against a written acceptance checklist. Once those boundaries are stable, add webhooks, broader multimodal inputs, batch scheduling, and human approval without hiding failures behind extra automation. To plan references and shots before credits are spent—and carry approved work through review and selective reruns—start the project with Seedance Agent.