Render Integration - OpenRouter with Render Workflows

OpenRouter handles model access and routing. Render Workflows handles the execution around those calls: queuing, retries, and parallel task runs. This guide deploys a small prompt batch. One task receives a list of prompts and fans out one retriable task run per prompt. Each run calls OpenRouter’s Auto Router and returns both the answer and the concrete model OpenRouter selected.

prompts -> Render Workflow fan-out -> OpenRouter Auto Router -> answers + model IDs

Each prompt becomes its own task run. Render provisions compute for those runs on demand and deprovisions it when they finish, so the fan-out does not require a pre-provisioned worker pool.

Render Workflow tasks do not expose HTTP ports. In a user-facing application, a Render Web Service receives the request and triggers the workflow. This guide starts with the workflow itself so you can deploy and verify the model pipeline first.

Prerequisites

You will need:

An OpenRouter API key
A Render account
The Render CLI installed and authenticated
A GitHub, GitLab, or Bitbucket repository you can push to

1. Create a workflow project

Use render workflows init to scaffold Render’s Hello World starter, then add the official OpenRouter Client SDK.

@openrouter/sdk is ESM-only. Use "type": "module" in package.json (or another ESM-compatible setup). CommonJS require() is not supported.

render workflows init \
  --confirm \
  --language node \
  --template hello-world \
  --dir openrouter-workflow

cd openrouter-workflow
npm install @openrouter/sdk@^1.1.22

render workflows init \
  --confirm \
  --language python \
  --template hello-world \
  --dir openrouter-workflow

cd openrouter-workflow
printf '\nopenrouter>=1.1.16,<2\n' >> requirements.txt
.venv/bin/pip install -r requirements.txt

The scaffold includes the Render SDK, creates a .env.example file and Git repository, and prints commands for local development and deployment.

2. Add your OpenRouter key

Copy the scaffolded environment file:

cp .env.example .env

Replace its contents with:

OPENROUTER_API_KEY=sk-or-v1-...
OPENROUTER_MODEL=openrouter/auto
OPENROUTER_APP_TITLE="Render Workflows Example"

The scaffold excludes .env from Git. Do not commit API keys. The Render CLI loads .env automatically during local Workflow development. If a public application will trigger this workflow, also set APP_URL to that application’s URL. OpenRouter uses APP_URL and OPENROUTER_APP_TITLE for app attribution.

Use openrouter/auto for OpenRouter’s Auto Router. The openrouter/auto-beta slug is the early-access track where new routing behavior lands first; see Auto Router.

3. Define the workflow

Replace the generated task file with the following code. The inner task makes one OpenRouter request and retries failures. The outer task fans out across every prompt. Render runs each chained task separately, so a slow or retried model call does not prevent the other calls from running.

import { OpenRouter } from '@openrouter/sdk';
import type { ChatResult } from '@openrouter/sdk/models';
import { task } from '@renderinc/sdk/workflows';

const apiKey = process.env.OPENROUTER_API_KEY;

if (!apiKey) {
  throw new Error('OPENROUTER_API_KEY is required');
}

const openRouter = new OpenRouter({
  apiKey,
  httpReferer: process.env.APP_URL,
  appTitle: process.env.OPENROUTER_APP_TITLE ?? 'Render Workflows Example',
});

function contentToText(content: unknown): string {
  if (typeof content === 'string') {
    return content;
  }

  if (!Array.isArray(content)) {
    return '';
  }

  return content
    .flatMap((item) => {
      if (
        typeof item === 'object' &&
        item !== null &&
        'text' in item &&
        typeof item.text === 'string'
      ) {
        return [item.text];
      }

      return [];
    })
    .join('\n');
}

const callOpenRouter = task(
  {
    name: 'callOpenRouter',
    retry: {
      maxRetries: 3,
      waitDurationMs: 1000,
      backoffScaling: 2,
    },
  },
  async function callOpenRouter(prompt: string) {
    const completion = (await openRouter.chat.send({
      chatRequest: {
        model: process.env.OPENROUTER_MODEL ?? 'openrouter/auto',
        messages: [{ role: 'user', content: prompt }],
        stream: false,
      },
    })) as ChatResult;

    return {
      prompt,
      model: completion.model,
      answer: contentToText(completion.choices[0]?.message.content),
    };
  },
);

const runPromptBatch = task(
  { name: 'runPromptBatch' },
  async function runPromptBatch(prompts: string[]) {
    return Promise.all(prompts.map((prompt) => callOpenRouter(prompt)));
  },
);

import asyncio
import os

from openrouter import OpenRouter
from render_sdk import Retry, Workflows

app = Workflows()


def content_to_text(content: object) -> str:
    if isinstance(content, str):
        return content

    if not isinstance(content, list):
        return ""

    parts: list[str] = []
    for item in content:
        text = getattr(item, "text", None)
        if isinstance(text, str):
            parts.append(text)

    return "\n".join(parts)


@app.task(
    name="call_openrouter",
    retry=Retry(
        max_retries=3,
        wait_duration_ms=1000,
        backoff_scaling=2,
    ),
)
def call_openrouter(prompt: str):
    with OpenRouter(
        api_key=os.environ["OPENROUTER_API_KEY"],
        http_referer=os.getenv("APP_URL"),
        x_open_router_title=os.getenv(
            "OPENROUTER_APP_TITLE",
            "Render Workflows Example",
        ),
    ) as open_router:
        completion = open_router.chat.send(
            model=os.getenv("OPENROUTER_MODEL", "openrouter/auto"),
            messages=[{"role": "user", "content": prompt}],
        )

    content = completion.choices[0].message.content if completion.choices else None

    return {
        "prompt": prompt,
        "model": completion.model,
        "answer": content_to_text(content),
    }


@app.task(name="run_prompt_batch")
async def run_prompt_batch(prompts: list[str]):
    return await asyncio.gather(*(call_openrouter(prompt) for prompt in prompts))


if __name__ == "__main__":
    app.start()

Auto Router can choose a different model for each independent prompt. Keeping completion.model in every result makes that routing decision visible.

A retried task can repeat a billable API call if the first request succeeded but the task failed before returning its result. For production workflows with external side effects, add application-level idempotency or checkpointing.

4. Test the workflow locally

Start Render’s local Workflow server:

render workflows dev -- npm start

render workflows dev -- .venv/bin/python main.py

In another terminal, start the batch task:

render workflows start runPromptBatch \
  --local \
  --input='[["Explain retries in one sentence.", "Write a haiku about databases."]]'

render workflows start run_prompt_batch \
  --local \
  --input='[["Explain retries in one sentence.", "Write a haiku about databases."]]'

The outer JSON array contains the task’s arguments. The inner array is the prompts argument. The command returns a task-run ID. Inspect the completed run with:

render workflows tasks runs show --local TASK_RUN_ID

A successful result contains one entry per prompt:

[
  {
    "prompt": "Explain retries in one sentence.",
    "model": "<model selected by OpenRouter>",
    "answer": "<generated response>"
  },
  {
    "prompt": "Write a haiku about databases.",
    "model": "<model selected by OpenRouter>",
    "answer": "<generated response>"
  }
]

5. Deploy the workflow to Render

Commit the project and push it to GitHub, GitLab, or Bitbucket. From the project directory, create the Workflow service with the Render CLI. --repo . reads the remote URL from the Git repository. --env-file .env adds the OpenRouter configuration to the Render service without committing the file.

render workflows create \
  --name openrouter-workflow \
  --repo . \
  --runtime node \
  --build-command "npm install" \
  --run-command "npm start" \
  --env-file .env \
  --output text

render workflows create \
  --name openrouter-workflow \
  --repo . \
  --runtime python \
  --build-command "pip install -r requirements.txt" \
  --run-command "python main.py" \
  --env-file .env \
  --output text

Render pulls the repository, builds the Workflow service, and registers both tasks. You can also create the service in the Render Dashboard by selecting New > Workflow and using the same build and run commands.

6. Run the deployed workflow

Start the deployed batch with its full task slug:

render workflows start openrouter-workflow/runPromptBatch \
  --input='[["Summarize eventual consistency.", "Name three uses for embeddings."]]'

render workflows start openrouter-workflow/run_prompt_batch \
  --input='[["Summarize eventual consistency.", "Name three uses for embeddings."]]'

Inspect the returned task-run ID:

render workflows tasks runs show TASK_RUN_ID

You can also open the Workflow service in the Render Dashboard to inspect the parent run, each chained model call, retries, logs, results, and the concrete model selected for every prompt.

Run render workflows tasks list and select the workflow, or copy the full task slug from the task page in the Render Dashboard.

7. Trigger the workflow from an application

The CLI is the quickest way to verify the deployment. A web service can start the same task through the Render SDK. Set RENDER_API_KEY in the web service or application environment, not in the Workflow service unless the Workflow itself needs to call the Render API.

import { Render } from '@renderinc/sdk';

async function main() {
  const render = new Render();

  const startedRun = await render.workflows.startTask(
    'openrouter-workflow/runPromptBatch',
    [['Summarize eventual consistency.', 'Name three uses for embeddings.']],
  );

  const finishedRun = await startedRun.get();
  console.log(finishedRun.results);
}

main().catch(console.error);

import asyncio

from render_sdk import RenderAsync


async def main():
    render = RenderAsync()

    started_run = await render.workflows.start_task(
        "openrouter-workflow/run_prompt_batch",
        [[
            "Summarize eventual consistency.",
            "Name three uses for embeddings.",
        ]],
    )

    finished_run = await started_run
    print(finished_run.results)


if __name__ == "__main__":
    asyncio.run(main())

Keep the web service focused on HTTP, authentication, and returning progress to the client. Put the OpenRouter calls in Workflow tasks so they can continue after the original request ends, retry independently, and fan out on demand. Use a shared environment group when the web service and Workflow service need the same OpenRouter configuration.

Deploy a complete example

Answer Arena is a TypeScript application that combines a Render Web Service, Render Postgres, Render Workflows, and OpenRouter. It fans out model configurations, streams progress to the browser, and records model, cost, and evaluation results.

Overview

Models & Routing

Features

Ori

Privacy

Best Practices

Community

Render

Prerequisites

1. Create a workflow project

2. Add your OpenRouter key

3. Define the workflow

4. Test the workflow locally

5. Deploy the workflow to Render

6. Run the deployed workflow

7. Trigger the workflow from an application

Deploy a complete example

Resources

​Prerequisites

​1. Create a workflow project

​2. Add your OpenRouter key

​3. Define the workflow

​4. Test the workflow locally

​5. Deploy the workflow to Render

​6. Run the deployed workflow

​7. Trigger the workflow from an application

​Deploy a complete example

​Resources

Prerequisites

1. Create a workflow project

2. Add your OpenRouter key

3. Define the workflow

4. Test the workflow locally

5. Deploy the workflow to Render

6. Run the deployed workflow

7. Trigger the workflow from an application

Deploy a complete example

Resources