Apps and components

The app and component tools let an assistant use workflows that people published. An app is a published workflow with a simple form, such as a photo restoration or a themed edit, and a component is a published building block. The assistant searches for one, reads its inputs, and runs it with your credits.

Apps cover many requests that no single generation tool handles, such as novel transformations, themed edits and multi-step pipelines. An assistant should search the apps before it answers that something cannot be done.

list_apps

Searches published apps: the public marketplace, or your own apps.

Permission: apps:read. Credits: free.

Returns: the matching apps with their slugs. Each app's estimated_credits is the price the app lists. When the price follows the length of a recording you give the app, such as an Apply EDL render of a whole episode, estimated_credits is the fixed part and per_minute_credits is the credits per minute of the recording. When the app has a list input you fill, per_item_credits is what each item beyond the creator's saved items adds. Both are 0 or absent when they do not apply.

The listed price is a range. The fields above are the "from" price, at the app's saved settings. max_estimated_credits, max_per_minute_credits and max_per_item_credits are the "up to" price: the most a run can cost over the choices the app's user has. They appear only when they differ from the "from" price. An app published before the range existed has them only after its next publish.

When a listed price includes a metered LLM call, the row carries estimated_credits_is_estimate: true. The figure is then the model's typical call, and the run is charged for the tokens the call actually used, so show the price as ≈N. The field is absent for a fixed price.

On a deployment that does not allow public work (outputs.allowPublic: false), the public scope lists nothing: { "data": [], "scope": "public", "next_cursor": null }. Your own apps are still listed with scope: "mine".

get_app_inputs

Returns the inputs of an app, the same form the app's page shows. Call it before run_app to learn the input keys.

Permission: apps:read. Credits: free.

Returns: the app's slug, name and description, and one entry per input, with its key, label, type (image, video, audio, text, select, number, boolean, list or color), whether it is required, and the options of a select.

• A slider the app exposes, such as a Text to Speech Stability, an LLM Temperature or a Duration, is type: "number" with the slider's own min, max and step. run_app accepts a number or a numeric string for it.
• A quick setting the app exposes, such as the model, resolution, duration, aspect ratio or Draft choice of a node, is typed by what it takes. It is a select whose options are its values, a number with min and max for a setting that takes any value in a range, or a boolean, such as Draft or Instrumental. When the choices depend on the node's model, options lists the values of every model and the description says so. Choose a value that the node's model takes. run_app turns a numeric string into a number and "true" or "false" into a boolean for these inputs. A value outside a fixed list is refused with 400 validation_error.
• A Video URL input is type: "video" and required: true. Its value is a link to a video: the video's page, or another public web link. A value that is not a web link is refused with 400 locked_field. From a site whose video length Nodaro reads first, a video of 4 minutes or more is downloaded only as a part you name in inputOverrides, with sectionStartSec and sectionEndSec on the node. A run without the part is refused before anything is billed.

On a deployment that does not allow public work (outputs.allowPublic: false), an app is its creator's alone. Another person's app answers App "<slug>" not found., as an unknown slug does.

run_app

Runs a published app. You pay the credits of the run.

Permission: workflows:execute. Credits: the credits of the nodes that run inside the app.

Returns: an execution id, and the run's runId. Follow the run with get_app_run. When the run fails, retry_app_run takes the runId.

inputOverrides cannot set where an output goes, such as the URL of a Webhook Output node, the account of a publishing node, or the target of a scraper. A run that tries is refused with 400 locked_field.

On a deployment that does not allow public work (outputs.allowPublic: false), only your own apps run. Another person's app is refused with 404 not_found, as an app that does not exist.

retry_app_run

Retries a failed app run from where it stopped. This is the Retry button on the app's page. Only the steps the run did not complete run, and only those are charged. Every step it completed hands on its result. A UGC Clip that failed renders only the clips it did not finish. The Retry runs the app version the run ran, with the inputs the run applied, and takes no inputs of its own.

Permission: workflows:execute. Credits: the steps that run again, with the creator's fee on the app.

Returns: without confirm, a quote, and nothing starts. The quote holds the steps that would run again, the price (estimatedCredits, the creator's fee included), reusedClips, and sufficient. sufficient says whether the balance and the app credits cover the Retry. appCreditsAllowance appears when the app credits are what stops it, and the quote then says so. Show the quote to the user, and call again with confirm: true only once they accept it. The tool then quotes again, which also checks the run, and starts the Retry. It returns the execution id: poll it with get_app_run.

• One Retry at a time. A second call while that Retry is pending is refused with already_running, and the error names the execution to poll.
• A changed app. When the app changed since the run, a plain Retry is refused with app_run_version_changed, which names the run's version and the app's. Start the run over with run_app, or pass the run's own version to continue on it.
• Runs that start over. A run that completed or was stopped rather than failing, or whose version is no longer available, is started over with run_app. The error says which.
• A Preview. A Retry that would stop at a Preview render is refused with preview_review_required. Retry it from the app's page, where a person can review the Preview.
• Credits. A refusal for credits keeps the route's own message, about the app credits or the balance.

Every refusal is listed in Retry a failed run.

On a deployment that does not allow public work, a run of another person's app is not retried (404 not_found, as for an app that does not exist). get_app_run still reads it.

delete_app_run

Moves an app run to your archive. You can restore it or delete it for good at app.nodaro.ai/archived-runs. A run can be deleted for good only once it has finished or been stopped.

Permission: workflows:execute. Credits: free.

Returns: a confirmation.

list_components

Searches published components: the public marketplace, or your own. Use it when the user names a component, or asks for a multi-step pipeline that matches a known one.

Permission: workflows:read. Credits: free.

Returns: the matching components with their slugs. Each one carries estimated_credits, per_minute_credits and per_item_credits, and the matching max_ fields, read as in list_apps. A row that holds a metered LLM call's estimate carries estimated_credits_is_estimate: true, as in list_apps.

On a deployment that does not allow public work (outputs.allowPublic: false), the public scope lists nothing: { "data": [], "scope": "public", "next_cursor": null }. scope: "mine" works as before.

get_component_inputs

Returns the inputs of a component. Call it before run_component to learn the input keys.

Permission: workflows:read. Credits: free.

Returns: one entry per input, with its key, label, type and whether it is required.

On a deployment that does not allow public work (outputs.allowPublic: false), a component is its creator's alone. Another person's answers Component "<slug>" not found., as an unknown slug does.

run_component

Runs a published component.

Permission: workflows:execute. Credits: the credits of the nodes that run inside the component.

Returns: a job id. When the job completes, its output_data carries the component's outputs. In clients with MCP Apps, the job card shows the outputs one under the other.

On a deployment that does not allow public work (outputs.allowPublic: false), run_component runs your own components only. Another person's is refused with 404 not_found "Component not found". A component placed in a workflow still runs as part of that workflow's run with run_workflow.