# Render CLI Reference — Look up supported commands and options.



This reference is automatically generated from the Render CLI source.

View documentation for any command in the CLI itself by running the following:

```shell
render help <command>
```

## Global options

| Option | Description |
| --- | --- |
| `--confirm` | Skip all confirmation prompts |
| `--output`, `-o` | Output format: interactive, json, yaml, or text (auto: text in non-TTY contexts unless explicitly set) |

## Top-level commands

###### `docs`

Open the Render docs in your browser

*Usage:*

```bash
render docs
```

*Options:*

[Global options](#global-options) only

###### `environments <projectID>`

List environments for a specified project in the active workspace.
In interactive mode you can view each environment's individual services.

*Usage:*

```bash
render environments <projectID>
```

*Options:*

[Global options](#global-options) only

###### `kv-cli [keyValueID|keyValueName]`

Open a redis-cli or valkey-cli session to a Key Value instance. Optionally pass the key value id or name as an argument.
To pass arguments to redis-cli or valkey-cli, use the following syntax: render kv-cli [keyValueID|keyValueName] -- [redis-cli args]

*Usage:*

```bash
render kv-cli [keyValueID|keyValueName]
```

*Options:*

[Global options](#global-options) only

###### `login`

Login to Render using the dashboard

*Usage:*

```bash
render login
```

*Options:*

[Global options](#global-options) only

###### `logs`

View logs for services and datastores.

Use flags to filter logs by resource, instance, time, text, level, type, host, status code, method, or path.
Unlike in the dashboard, you can view logs for multiple resources at once. Set `--tail=true` to stream new logs (currently only in interactive mode).

In interactive mode you can update the filters and view logs in real time.

*Usage:*

```bash
render logs
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--direction` | The direction to query the logs. Can be 'forward' or 'backward' |
| `--end` | The end time of the logs to query |
| `--host` | A list of comma separated hosts to query |
| `--instance` | A list of comma separated instance IDs to query |
| `--level` | A list of comma separated log levels to query |
| `--limit` | The maximum number of logs to return |
| `--method` | A list of comma separated HTTP methods to query |
| `--path` | A list of comma separated paths to query |
| `--resources`, `-r` | A list of comma separated resource IDs to query. Required in non-interactive mode. |
| `--start` | The start time of the logs to query |
| `--status-code` | A list of comma separated status codes to query |
| `--tail` | Stream new logs |
| `--task-id` | A list of comma separated task IDs to query |
| `--task-run-id` | A list of comma separated task run IDs to query |
| `--text` | A list of comma separated strings to search for in the logs |
| `--type` | A list of comma separated log types to query |

###### `pgcli [postgresID|postgresName]`

Open a pgcli session to a PostgreSQL database. Optionally pass the database id or name as an argument.
To pass arguments to pgcli, use the following syntax: render pgcli [postgresID|postgresName] -- [pgcli args]

*Usage:*

```bash
render pgcli [postgresID|postgresName]
```

*Options:*

[Global options](#global-options) only

###### `projects`

List projects for the active workspace.
In interactive mode you can view the environments for a project.

*Usage:*

```bash
render projects
```

*Options:*

[Global options](#global-options) only

###### `psql [postgresID|postgresName]`

Open a psql session to a PostgreSQL database. Optionally pass the database id or name as an argument.
To pass arguments to psql, use the following syntax: render psql [postgresID|postgresName] -- [psql args]

For non-interactive usage, use the `--command` flag:
  render psql [postgresID|postgresName] -c "SELECT * FROM users;" -o text

Additional psql flags can be passed after --:
  render psql [postgresID|postgresName] -c "SELECT 1;" -o json -- `--csv` -q

*Usage:*

```bash
render psql [postgresID|postgresName]
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--command`, `-c` | SQL command to execute (enables non-interactive mode) |

###### `restart [resourceID]`

Restart a service

*Usage:*

```bash
render restart [resourceID]
```

*Options:*

[Global options](#global-options) only

###### `ssh [serviceID|serviceName|instanceID]`

SSH into a service instance. You can specify the service ID, service name, or specific instance ID as an argument.

To pass arguments to ssh, use the following syntax: render ssh [serviceID|serviceName|instanceID] -- [ssh args]

*Usage:*

```bash
render ssh [serviceID|serviceName|instanceID]
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--ephemeral`, `-e` | connect to ephemeral instance |

###### `whoami`

Display information about the current user

*Usage:*

```bash
render whoami
```

*Options:*

[Global options](#global-options) only

###### `workspaces`

List workspaces

*Usage:*

```bash
render workspaces
```

*Options:*

[Global options](#global-options) only

## Blueprints

###### `blueprints validate [file]`

Validate a render.yaml Blueprint file for errors before committing.

Validates:
  - YAML syntax
  - Schema validation (required fields, types)
  - Semantic validation (valid plans, regions, etc.)
  - Conflict checking against existing resources

*Usage:*

```bash
render blueprints validate [file]
```

*Examples:*

```bash
render blueprints validate                    # Validate ./render.yaml
render blueprints validate ./my-blueprint.yaml  # Validate specific file
render blueprints validate -o json            # Output as JSON
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--workspace`, `-w` | Workspace ID to validate against (defaults to current workspace) |

## Deploys

###### `deploys cancel <serviceID> <deployID>`

Cancel a running deploy

*Usage:*

```bash
render deploys cancel <serviceID> <deployID>
```

*Options:*

[Global options](#global-options) only

###### `deploys create [serviceID]`

Trigger a service deploy and tail logs

*Usage:*

```bash
render deploys create [serviceID]
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--clear-cache` | Clear build cache before deploying |
| `--commit` | The commit ID to deploy |
| `--image` | The Docker image URL to deploy |
| `--wait` | Wait for deploy to finish. Returns non-zero exit code if deploy fails |

###### `deploys list [serviceID]`

List deploys for a service

*Usage:*

```bash
render deploys list [serviceID]
```

*Options:*

[Global options](#global-options) only

## Jobs

###### `jobs cancel <serviceID> <jobID>`

Cancel a running job

*Usage:*

```bash
render jobs cancel <serviceID> <jobID>
```

*Options:*

[Global options](#global-options) only

###### `jobs create [serviceID]`

Create a new job for a service

*Usage:*

```bash
render jobs create [serviceID]
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--plan-id` | The plan ID for the job (optional) |
| `--start-command` | The command to run for the job |

###### `jobs list [serviceID]`

List jobs for a service

*Usage:*

```bash
render jobs list [serviceID]
```

*Options:*

[Global options](#global-options) only

## Services

###### `services`

Lists all services and datastores for the active workspace. In interactive mode, you can view logs, restart services, trigger deploys, SSH into instances, and connect to PostgreSQL and Key Value datastores.

*Usage:*

```bash
render services
```

*Aliases:* `service`

*Available commands:*

| Command | Description |
| --- | --- |
| [`create`](#services-create) | Create a new service |
| [`instances`](#services-instances) | List instances for a service |
| [`update`](#services-update) | Update a service |

*Examples:*

```bash
# List all services
render services

# Output as JSON
render services --output json

# Filter by environment
render services -e env-abc123

# Include preview environments
render services --include-previews

# Combine filters
render services -e env-abc123,env-def456 --include-previews --output json
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--environment-ids`, `-e` | Filter services by environment IDs |
| `--include-previews` | Include preview environments |

###### `services create`

Create a new service on Render.

This command currently runs in non-interactive mode only.
Provide all config with flags.

*Usage:*

```bash
render services create
```

*Examples:*

```bash
render services create --name my-api --type web_service --repo https://github.com/org/repo --output json
render services create --from srv-abc123 --name my-api-clone --output json
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--auto-deploy` | Enable auto-deploy |
| `--branch` | Git branch |
| `--build-command` | Build command |
| `--build-filter-ignored-path` | Build filter ignored path (can be specified multiple times) |
| `--build-filter-path` | Build filter path (can be specified multiple times) |
| `--cron-command` | Cron command |
| `--cron-schedule` | Cron schedule |
| `--env-var` | Environment variable in `KEY=VALUE` format (can be specified multiple times) |
| `--environment-id` | Environment ID |
| `--from` | Clone configuration from existing service (ID or name). Other flags override cloned values. |
| `--health-check-path` | Health check path |
| `--image` | Docker image URL |
| `--ip-allow-list` | IP allow list entry in `cidr=...,description=`... format (can be specified multiple times) |
| `--maintenance-mode` | Enable maintenance mode |
| `--maintenance-mode-uri` | Maintenance mode URI |
| `--max-shutdown-delay` | Max shutdown delay in seconds |
| `--name` | Service name |
| `--num-instances` | Number of instances |
| `--plan` | Service plan |
| `--pre-deploy-command` | Pre-deploy command |
| `--previews` | Preview generation mode |
| `--publish-directory` | Publish directory |
| `--region` | Deployment region |
| `--registry-credential` | Registry credential |
| `--repo` | Git repository URL |
| `--root-directory` | Root directory |
| `--runtime` | Runtime environment |
| `--secret-file` | Secret file in NAME:`LOCAL_PATH` format (can be specified multiple times) |
| `--start-command` | Start command |
| `--type` | Service type |

###### `services instances [serviceID]`

List instances for a service

*Usage:*

```bash
render services instances [serviceID]
```

*Options:*

[Global options](#global-options) only

###### `services update [service]`

Update a service on Render.

This command currently runs in non-interactive mode only.
Provide all updates with flags.

*Usage:*

```bash
render services update [service]
```

*Examples:*

```bash
render services update my-service --name my-new-name --output json
render services update srv-abc123 --plan pro --output json
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--auto-deploy` | Enable auto-deploy |
| `--branch` | Git branch |
| `--build-command` | Build command |
| `--build-filter-ignored-path` | Build filter ignored path (can be specified multiple times) |
| `--build-filter-path` | Build filter path (can be specified multiple times) |
| `--cron-command` | Cron command |
| `--cron-schedule` | Cron schedule |
| `--health-check-path` | Health check path |
| `--image` | Docker image URL |
| `--ip-allow-list` | IP allow list entry in `cidr=...,description=`... format (can be specified multiple times) |
| `--maintenance-mode` | Enable maintenance mode |
| `--maintenance-mode-uri` | Maintenance mode URI |
| `--max-shutdown-delay` | Max shutdown delay in seconds |
| `--name` | Service name |
| `--num-instances` | Number of instances |
| `--plan` | Service plan |
| `--pre-deploy-command` | Pre-deploy command |
| `--previews` | Preview generation mode |
| `--publish-directory` | Publish directory |
| `--registry-credential` | Registry credential |
| `--repo` | Git repository URL |
| `--root-directory` | Root directory |
| `--runtime` | Runtime environment |
| `--start-command` | Start command |

## Skills

###### `skills`

Install and manage Render agent skills for AI coding tools such as Claude Code, Codex, OpenCode, and Cursor.

Skills add deployment, debugging, and monitoring capabilities to your AI coding assistant.

*Usage:*

```bash
render skills
```

*Available commands:*

| Command | Description |
| --- | --- |
| [`install`](#skills-install) | Install Render skills to AI coding tools |
| [`list`](#skills-list) | List installed Render skills and detected tools |
| [`remove`](#skills-remove) | Remove installed Render skills from AI coding tools |
| [`update`](#skills-update) | Update previously installed Render skills |

*Options:*

[Global options](#global-options) only

###### `skills install`

Install Render agent skills from https://github.com/render-oss/skills to detected AI coding tools.

Supported tools: Claude Code, Codex, OpenCode, Cursor.

Skills can be installed at two scopes:
  - user:    Install to ~/.{tool}/skills/ (default, current user only)
  - project: Install to ./.{tool}/skills/ (committed to git, all collaborators)

By default an interactive prompt lets you pick scope, tools, and skills.
Use `--scope`, `--tool`, and `--skill` flags to skip the prompts (useful for CI).

*Usage:*

```bash
render skills install
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--dry-run` | show what would be installed without making changes |
| `--scope` | installation scope: user (default) or project |
| `--skill` | install specific skills only (e.g. `--skill` render-deploy `--skill` render-debug) |
| `--tool` | install to a specific tool only (claude, codex, opencode, cursor) |

###### `skills list`

Show which Render skills are currently installed and which AI coding tools they are installed to. This reads from local state only — no network access is required.

Use `--scope` to filter by installation scope (user or project).

*Usage:*

```bash
render skills list
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--scope` | filter by scope: user or project |

###### `skills remove`

Remove previously installed Render skills from detected AI coding tools.

By default an interactive prompt lets you pick which skills to remove.
Use `--skill` and `--all` flags to skip the prompts.

Use `--scope` to remove from a specific scope (user or project).

*Usage:*

```bash
render skills remove
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--all` | remove all installed Render skills |
| `--scope` | remove from specific scope: user or project |
| `--skill` | remove specific skills (e.g. `--skill` render-deploy `--skill` render-debug) |
| `--tool` | remove from a specific tool only (claude, codex, opencode, cursor) |

###### `skills update`

Re-install Render skills using the tool and skill selections saved by a previous "render skills install" run.

This fetches the latest version of each selected skill from the skills repository, compares with installed versions, and updates any that have changed.

Use `--scope` to update skills at a specific scope (user or project).

*Usage:*

```bash
render skills update
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--force` | reinstall all skills even if already up to date |
| `--scope` | update skills at specific scope: user or project |

## Workflows

###### `workflows dev -- <command to start a workflow service>`

Start a workflow service in development mode for local testing.

This command runs your workflow service locally on port 8120, allowing you to list and run tasks without deploying to Render. Task runs and their logs are stored in memory, so you can query them after tasks complete.

The command will spawn a new subprocess with your specified command whenever it needs to run a task or list the defined tasks.

To interact with the local task server:

- Use the `--local` flag with other task commands (e.g., 'render workflows tasks list `--local`')

- Or set `RENDER_USE_LOCAL_DEV=true` when using the workflow client SDK

To use a different port:

- Specify `--port` when starting the dev server

- Then use `--port` with other task commands, or set `RENDER_LOCAL_DEV_URL` in the SDK

*Usage:*

```bash
render workflows dev -- <command to start a workflow service>
```

*Examples:*

```bash
render workflows dev -- "python main.py"
render workflows dev --port 9000 -- "npm start"
render workflows tasks list --local
render workflows tasks start my-task --local --input='["arg1"]'
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--debug` | Print detailed workflow task execution events |
| `--port` | Port of the local task server (8120 when not specified) |

###### `workflows init`

Scaffold a new workflows project with example tasks.

Creates a working example project with task definitions, dependencies, and a README with instructions for local development and Client SDK integration.

In interactive mode you'll be prompted to select a language, template, output directory, and optional features. Use `--confirm` to skip all prompts and accept defaults, or pass individual flags to skip specific prompts.

*Usage:*

```bash
render workflows init
```

*Examples:*

```bash
render workflows init
render workflows init --confirm --language python
render workflows init --language python --dir my-project --install-deps --git
render workflows init --language node --dir my-project
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--dir` | Output directory (default: ./workflows-demo) |
| `--git` | Initialize a Git repository |
| `--install-agent-skill` | Install the Workflows agent skill for detected AI coding tools |
| `--install-deps` | Install dependencies after scaffolding |
| `--language` | Language for the workflows project (python, node) |
| `--template` | Template to scaffold (defaults to the repo's default template) |

###### `workflows list`

List workflows

*Usage:*

```bash
render workflows list
```

*Options:*

[Global options](#global-options) only

###### `workflows runs`

View task run executions.

A task run represents a single execution of a task with specific input parameters.
Use these commands to view task run history and inspect details.

To start a new task run, use 'render workflows tasks start'.

*Usage:*

```bash
render workflows runs
```

*Available commands:*

| Command | Description |
| --- | --- |
| [`list`](#workflows-runs-list) | List task runs for a task |
| [`show`](#workflows-runs-show) | Show detailed information about a task run |

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--local` | Run against the server spawned by the task dev command |
| `--port` | Port of the local task server (8120 when not specified) |

###### `workflows runs list [taskID]`

List all execution runs for a specific task.

A task run represents a single execution of a task with specific input parameters.
This command shows the history of all runs for a given task.

You can specify the task by its workflow slug and task name (e.g., my-workflow/my-task)

In interactive mode, you will be prompted to select a task if not provided.

*Usage:*

```bash
render workflows runs list [taskID]
```

*Examples:*

```bash
render workflows runs list tsk-1234
render workflows runs list my-workflow/my-task
render workflows runs list --local my-task
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--local` | Run against the server spawned by the task dev command |
| `--port` | Port of the local task server (8120 when not specified) |

###### `workflows runs show [taskRunID]`

Display detailed information about a specific task run execution.

This command shows comprehensive information about a task run, including:

- Task run ID and status

- Input parameters provided

- Output or error result

- Start and completion timestamps

The task run ID is returned when you execute a task with 'render workflows tasks start'.

In interactive mode, you will be prompted to select a task run if not provided.

*Usage:*

```bash
render workflows runs show [taskRunID]
```

*Examples:*

```bash
render workflows runs show tr-1234
render workflows runs show --local tr-5678
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--local` | Run against the server spawned by the task dev command |
| `--port` | Port of the local task server (8120 when not specified) |

###### `workflows tasks`

Manage tasks

*Usage:*

```bash
render workflows tasks
```

*Available commands:*

| Command | Description |
| --- | --- |
| [`list`](#workflows-tasks-list) | List tasks in a workflow version |
| [`start`](#workflows-tasks-start) | Start a task run with the provided input |

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--local` | Run against the server spawned by the task dev command |
| `--port` | Port of the local task server (8120 when not specified) |

###### `workflows tasks list [workflowVersionID]`

List all tasks defined in a workflow version.

Tasks are user-defined functions registered with the Render workflow SDK. Each time you release a workflow service, Render creates a new workflow version and registers all tasks it finds in that version.

In interactive mode, you will be prompted to select a workflow if not provided.

Local Development:
When using the `--local` flag, you don't need to provide a workflow version ID. Instead, the command connects to your local dev server (default port 8120) to list tasks from your running workflow service. Start the dev server with 'render workflows dev' first.

*Usage:*

```bash
render workflows tasks list [workflowVersionID]
```

*Examples:*

```bash
render workflows tasks list wfv-1234
render workflows tasks list --local
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--local` | Run against the server spawned by the task dev command |
| `--port` | Port of the local task server (8120 when not specified) |

###### `workflows tasks start [task-slug] --input=<json>`

Start a task with the provided input.

You can specify the task by its workflow slug and task name (e.g., my-workflow/my-task)

Input Format:
The input should be a JSON array where each element is an argument to the task.
For example, if your task takes two arguments, provide: ["arg1", "arg2"]

You can provide input via:

- `--input` with inline JSON

- `--input-file` with a path to a JSON file

In interactive mode, you will be prompted to select the task and provide the input.

*Usage:*

```bash
render workflows tasks start [task-slug] --input=<json>
```

*Examples:*

```bash
render workflows tasks start tsk-1234 --input='["arg1", "arg2"]'
render workflows tasks start my-workflow/my-task --input='[42, "hello"]'
render workflows tasks start my-task --input-file=input.json
render workflows tasks start my-task --local --input='["test"]'
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--input` | JSON array input to pass to the task (e.g., '["arg1", "arg2"]') |
| `--input-file` | File containing JSON input to pass to the task |
| `--local` | Run against the server spawned by the task dev command |
| `--port` | Port of the local task server (8120 when not specified) |

###### `workflows versions`

Manage workflow versions

*Usage:*

```bash
render workflows versions
```

*Available commands:*

| Command | Description |
| --- | --- |
| [`list`](#workflows-versions-list) | List versions of a workflow |
| [`release`](#workflows-versions-release) | Release a new workflow version |

*Options:*

[Global options](#global-options) only

###### `workflows versions list [workflowID]`

List all versions of a workflow service.

Each time you release a workflow service, Render creates a new workflow version. A version represents a specific snapshot of your workflow service code and its registered tasks at the time of release.

This command displays all versions for a workflow, showing:

- Version ID

- Creation timestamp

- Associated tasks

In interactive mode, you will be prompted to select a workflow if not provided.

*Usage:*

```bash
render workflows versions list [workflowID]
```

*Examples:*

```bash
render workflows versions list wf-1234
render workflows versions list my-workflow-slug
```

*Options:*

[Global options](#global-options) only

###### `workflows versions release [workflowID]`

Release a new version of a workflow service.

This command triggers a new release of your workflow service on Render. When you release,
Render:

1. Pulls the latest code from your repository (or a specific commit)

2. Builds your workflow service

3. Registers all tasks it finds in the service

4. Creates a new workflow version

You can optionally specify a commit ID to release a specific version of your code.

Flags:
  `--commit`    Specify a commit ID to release (optional)
  `--wait`      Wait for the release to complete before returning (optional)
              Returns a non-zero exit code if the release fails

In interactive mode, you will be prompted to:

- Select a workflow if not provided

- Confirm the release

*Usage:*

```bash
render workflows versions release [workflowID]
```

*Examples:*

```bash
render workflows versions release wf-1234
render workflows versions release my-workflow-slug
render workflows versions release wf-1234 --commit abc123
render workflows versions release wf-1234 --wait
```

*Options:*

[Global options](#global-options), plus:

| Option | Description |
| --- | --- |
| `--commit` | The commit ID to release |
| `--wait` | Wait for release to finish. Returns non-zero exit code if release fails |

## Workspace

###### `workspace current`

Show the currently selected workspace

*Usage:*

```bash
render workspace current
```

*Options:*

[Global options](#global-options) only

###### `workspace set [workspaceName|workspaceID]`

Set the CLI's active workspace. All CLI commands run against the active workspace.

The active workspace is saved in a config file specified by the `RENDER_CLI_CONFIG_PATH` environment variable.
If unspecified, the config file is saved in $HOME/.render/cli.yaml.

*Usage:*

```bash
render workspace set [workspaceName|workspaceID]
```

*Options:*

[Global options](#global-options) only