Heroku CLI Commands

Last updated April 30, 2025

These are the help texts for each of the core Heroku CLI commands. You can also see this text in your terminal with heroku help, heroku --help, or heroku -h.

heroku access:remove

remove users from a team app

USAGE
  $ heroku access:remove -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  remove users from a team app

EXAMPLES
  $ heroku access:remove user@email.com --app APP

See code: src/commands/access/remove.ts

heroku access:update EMAIL

update existing collaborators on an team app

USAGE
  $ heroku access:update EMAIL -p <value> -a <value> [-r <value>]

ARGUMENTS
  EMAIL  email address of the team member

FLAGS
  -a, --app=<value>          (required) app to run command against
  -p, --permissions=<value>  (required) comma-delimited list of permissions to
                             update (deploy,manage,operate)
  -r, --remote=<value>       git remote of app to use

DESCRIPTION
  update existing collaborators on an team app

See code: src/commands/access/update.ts

heroku accounts

list the Heroku accounts in your cache

USAGE
  $ heroku accounts

DESCRIPTION
  list the Heroku accounts in your cache

EXAMPLES
  $ heroku accounts

See code: src/commands/accounts/index.ts

heroku accounts:current

display the current Heroku account

USAGE
  $ heroku accounts:current

DESCRIPTION
  display the current Heroku account

EXAMPLES
  $ heroku accounts:current

See code: src/commands/accounts/current.ts

heroku accounts:remove NAME

remove a Heroku account from your cache

USAGE
  $ heroku accounts:remove NAME

ARGUMENTS
  NAME  name of Heroku account to remove

DESCRIPTION
  remove a Heroku account from your cache

EXAMPLES
  $ heroku accounts:remove my-account

See code: src/commands/accounts/remove.ts

heroku addons [--all|--app APP]

Lists your add-ons and attachments.

USAGE
  $ heroku addons [--all|--app APP]

FLAGS
  -A, --all             show add-ons and attachments for all accessible apps
  -a, --app=<value>     app to run command against
  -r, --remote=<value>  git remote of app to use
      --json            return add-ons in json format

DESCRIPTION
  Lists your add-ons and attachments.

  The default filter applied depends on whether you are in a Heroku app
  directory. If so, the --app flag is implied. If not, the default of --all
  is implied. Explicitly providing either flag overrides the default
  behavior.


EXAMPLES
  $ heroku addons --all

  $ heroku addons --app acme-inc-www

See code: src/commands/addons/index.ts

heroku addons:attach ADDON_NAME

attach an existing add-on resource to an app

USAGE
  $ heroku addons:attach ADDON_NAME -a <value> [--as <value>] [--credential
    <value>] [--confirm <value>] [-r <value>]

ARGUMENTS
  ADDON_NAME  unique identifier or globally unique name of the add-on

FLAGS
  -a, --app=<value>         (required) app to run command against
  -r, --remote=<value>      git remote of app to use
      --as=<value>          name for add-on attachment
      --confirm=<value>     overwrite existing add-on attachment with same name
      --credential=<value>  credential name for scoped access to Heroku Postgres

DESCRIPTION
  attach an existing add-on resource to an app

See code: src/commands/addons/attach.ts

heroku addons:create SERVICE:PLAN

Create a new add-on resource.

USAGE
  $ heroku addons:create SERVICE:PLAN... -a <value> [--name <value>] [--as
    <value>] [--confirm <value>] [--wait] [-r <value>]

ARGUMENTS
  SERVICE:PLAN...  unique identifier or unique name of the add-on service plan

FLAGS
  -a, --app=<value>      (required) app to run command against
  -r, --remote=<value>   git remote of app to use
      --as=<value>       name for the initial add-on attachment
      --confirm=<value>  overwrite existing config vars or existing add-on
                         attachments
      --name=<value>     name for the add-on resource
      --wait             watch add-on creation status and exit when complete

DESCRIPTION
  Create a new add-on resource.

  In order to add additional config items, please place them at the end of the
  command after a double-dash (--).


EXAMPLES
  Create an add-on resource:
  $heroku addons:create heroku-redis --app my-app
  Create an add-on resource with additional config items:
  $heroku addons:create heroku-postgresql:standard-0 --app my-app -- --fork DATABASE

See code: src/commands/addons/create.ts

heroku addons:destroy ADDONNAME

permanently destroy an add-on resource

USAGE
  $ heroku addons:destroy ADDONNAME... [-f] [-c <value>] [--wait] [-a
    <value>] [-r <value>]

ARGUMENTS
  ADDONNAME...  unique identifier or globally unique name of the add-on

FLAGS
  -a, --app=<value>      app to run command against
  -c, --confirm=<value>
  -f, --force            allow destruction even if connected to other apps
  -r, --remote=<value>   git remote of app to use
      --wait             watch add-on destruction status and exit when complete

DESCRIPTION
  permanently destroy an add-on resource

EXAMPLES
  addons:destroy [ADDON]... [flags]

See code: src/commands/addons/destroy.ts

heroku addons:detach ATTACHMENT_NAME

detach an existing add-on resource from an app

USAGE
  $ heroku addons:detach ATTACHMENT_NAME -a <value> [-r <value>]

ARGUMENTS
  ATTACHMENT_NAME  unique identifier of the add-on attachment

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  detach an existing add-on resource from an app

See code: src/commands/addons/detach.ts

heroku addons:rename ADDON_NAME NEW_NAME

rename an add-on

USAGE
  $ heroku addons:rename ADDON_NAME NEW_NAME

ARGUMENTS
  ADDON_NAME  unique identifier or globally unique name of the add-on
  NEW_NAME    new globally unique name of the add-on

DESCRIPTION
  rename an add-on

See code: src/commands/addons/rename.ts

heroku addons:services

list all available add-on services

USAGE
  $ heroku addons:services [--json]

FLAGS
  --json  output in json format

DESCRIPTION
  list all available add-on services

See code: src/commands/addons/services.ts

heroku addons:upgrade ADDON [PLAN]

change add-on plan.

USAGE
  $ heroku addons:upgrade ADDON [PLAN] [-a <value>] [-r <value>]

ARGUMENTS
  ADDON  unique identifier or globally unique name of the add-on
  PLAN   unique identifier or name of the plan

FLAGS
  -a, --app=<value>     app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  change add-on plan.
  See available plans with `heroku addons:plans SERVICE`.

  Note that `heroku addons:upgrade` and `heroku addons:downgrade` are the same.
  Either one can be used to change an add-on plan up or down.

  https://devcenter.heroku.com/articles/managing-add-ons


ALIASES
  $ heroku addons:downgrade

EXAMPLES
  Upgrade an add-on by service name:
  $ heroku addons:upgrade heroku-redis:premium-2
  Upgrade a specific add-on:
  $ heroku addons:upgrade swimming-briskly-123 heroku-redis:premium-2

See code: src/commands/addons/upgrade.ts

heroku apps:favorites

list favorited apps

USAGE
  $ heroku apps:favorites [-j]

FLAGS
  -j, --json  output in json format

DESCRIPTION
  list favorited apps

See code: src/commands/apps/favorites/index.ts

heroku apps:favorites:add

favorites an app

USAGE
  $ heroku apps:favorites:add -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  favorites an app

See code: src/commands/apps/favorites/add.ts

heroku apps:favorites:remove

unfavorites an app

USAGE
  $ heroku apps:favorites:remove -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  unfavorites an app

See code: src/commands/apps/favorites/remove.ts

heroku apps:stacks

show the list of available stacks

USAGE
  $ heroku apps:stacks -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  show the list of available stacks

See code: src/commands/apps/stacks/index.ts

heroku apps:stacks:set STACK

set the stack of an app

USAGE
  $ heroku apps:stacks:set STACK -a <value> [-r <value>]

ARGUMENTS
  STACK  unique name or identifier of the stack

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  set the stack of an app

EXAMPLES
  $ heroku stack:set heroku-24 -a myapp
  Setting stack to heroku-24... done
  You will need to redeploy myapp for the change to take effect.
  Run git push heroku main to trigger a new build on myapp.

See code: src/commands/apps/stacks/set.ts

heroku apps:transfer RECIPIENT

transfer applications to another user or team

USAGE
  $ heroku apps:transfer RECIPIENT [-l] [--bulk] [-a <value>] [-r <value>]

ARGUMENTS
  RECIPIENT  user or team to transfer applications to

FLAGS
  -a, --app=<value>     app to run command against
  -l, --locked          lock the app upon transfer
  -r, --remote=<value>  git remote of app to use
      --bulk            transfer applications in bulk

DESCRIPTION
  transfer applications to another user or team

EXAMPLES
  $ heroku apps:transfer collaborator@example.com
  Transferring example to collaborator@example.com... done
  $ heroku apps:transfer acme-widgets
  Transferring example to acme-widgets... done
  $ heroku apps:transfer --bulk acme-widgets
  ...

See code: src/commands/apps/transfer.ts

heroku auth:2fa

check 2fa status

USAGE
  $ heroku auth:2fa

DESCRIPTION
  check 2fa status

ALIASES
  $ heroku 2fa
  $ heroku twofactor

See code: src/commands/auth/2fa/index.ts

heroku authorizations

list OAuth authorizations

USAGE
  $ heroku authorizations [-j]

FLAGS
  -j, --json  output in json format

DESCRIPTION
  list OAuth authorizations

EXAMPLES
  $ heroku authorizations

See code: src/commands/authorizations/index.ts

heroku authorizations:create

create a new OAuth authorization

USAGE
  $ heroku authorizations:create [-d <value>] [-S] [-j] [-s <value>] [-e
  <value>]

FLAGS
  -S, --short                only output token
  -d, --description=<value>  set a custom authorization
  -e, --expires-in=<value>   set expiration in seconds (default no expiration)
  -j, --json                 output in json format
  -s, --scope=<value>        set custom OAuth scopes

DESCRIPTION
  create a new OAuth authorization

EXAMPLES
  $ heroku authorizations:create --description "For use with Anvil"

See code: src/commands/authorizations/create.ts

heroku authorizations:info ID

show an existing OAuth authorization

USAGE
  $ heroku authorizations:info ID [-j]

ARGUMENTS
  ID  ID of the authorization

FLAGS
  -j, --json  output in json format

DESCRIPTION
  show an existing OAuth authorization

See code: src/commands/authorizations/info.ts

heroku authorizations:rotate ID

updates an OAuth authorization token

USAGE
  $ heroku authorizations:rotate ID

ARGUMENTS
  ID  ID of the authorization

DESCRIPTION
  updates an OAuth authorization token

See code: src/commands/authorizations/rotate.ts

heroku authorizations:update ID

updates an OAuth authorization

USAGE
  $ heroku authorizations:update ID [-d <value>] [--client-id <value>
    --client-secret <value>]

ARGUMENTS
  ID  ID of the authorization

FLAGS
  -d, --description=<value>    set a custom authorization description
      --client-id=<value>      identifier of OAuth client to set
      --client-secret=<value>  secret of OAuth client to set

DESCRIPTION
  updates an OAuth authorization

See code: src/commands/authorizations/update.ts

heroku autocomplete [SHELL]

display autocomplete installation instructions

USAGE
  $ heroku autocomplete [SHELL] [-r]

ARGUMENTS
  SHELL  shell type

FLAGS
  -r, --refresh-cache  refresh cache only (ignores displaying instructions)

DESCRIPTION
  display autocomplete installation instructions

EXAMPLES
  $ heroku autocomplete

  $ heroku autocomplete bash

  $ heroku autocomplete zsh

  $ heroku autocomplete --refresh-cache

See code: src/commands/autocomplete/index.ts

heroku buildpacks

list the buildpacks on an app

USAGE
  $ heroku buildpacks -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  list the buildpacks on an app

See code: src/commands/buildpacks/index.ts

heroku buildpacks:add BUILDPACK

add new app buildpack, inserting into list of buildpacks if necessary

USAGE
  $ heroku buildpacks:add BUILDPACK -a <value> [-r <value>] [-i <value>]

ARGUMENTS
  BUILDPACK  namespace/name of the buildpack

FLAGS
  -a, --app=<value>     (required) app to run command against
  -i, --index=<value>   the 1-based index of the URL in the list of URLs
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  add new app buildpack, inserting into list of buildpacks if necessary

See code: src/commands/buildpacks/add.ts

heroku buildpacks:clear

clear all buildpacks set on the app

USAGE
  $ heroku buildpacks:clear -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  clear all buildpacks set on the app

See code: src/commands/buildpacks/clear.ts

heroku buildpacks:info BUILDPACK

fetch info about a buildpack

USAGE
  $ heroku buildpacks:info BUILDPACK

ARGUMENTS
  BUILDPACK  namespace/name of the buildpack

DESCRIPTION
  fetch info about a buildpack

See code: src/commands/buildpacks/info.ts

heroku buildpacks:remove [BUILDPACK]

remove a buildpack set on the app

USAGE
  $ heroku buildpacks:remove [BUILDPACK] -a <value> [-r <value>] [-i <value>]

ARGUMENTS
  BUILDPACK  namespace/name of the buildpack

FLAGS
  -a, --app=<value>     (required) app to run command against
  -i, --index=<value>   the 1-based index of the URL to remove from the list of
                        URLs
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  remove a buildpack set on the app

See code: src/commands/buildpacks/remove.ts

heroku buildpacks:search [TERM]

search for buildpacks

USAGE
  $ heroku buildpacks:search [TERM] [--namespace <value>] [--name <value>]
    [--description <value>]

ARGUMENTS
  TERM  search term that searches across name, namespace, and description

FLAGS
  --description=<value>  buildpack description to filter on
  --name=<value>         buildpack names to filter on using a comma separated
                         list
  --namespace=<value>    buildpack namespaces to filter on using a comma
                         separated list

DESCRIPTION
  search for buildpacks

See code: src/commands/buildpacks/search.ts

heroku buildpacks:set BUILDPACK

USAGE
  $ heroku buildpacks:set BUILDPACK -a <value> [-r <value>] [-i <value>]

ARGUMENTS
  BUILDPACK  namespace/name of the buildpack

FLAGS
  -a, --app=<value>     (required) app to run command against
  -i, --index=<value>   the 1-based index of the URL in the list of URLs
  -r, --remote=<value>  git remote of app to use

See code: src/commands/buildpacks/set.ts

heroku buildpacks:versions BUILDPACK

list versions of a buildpack

USAGE
  $ heroku buildpacks:versions BUILDPACK

ARGUMENTS
  BUILDPACK  namespace/name of the buildpack

DESCRIPTION
  list versions of a buildpack

See code: src/commands/buildpacks/versions.ts

heroku certs:auto

show ACM status for an app

USAGE
  $ heroku certs:auto -a <value> [--wait] [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
      --wait            watch ACM status and display the status when complete

DESCRIPTION
  show ACM status for an app

See code: src/commands/certs/auto/index.ts

heroku certs:auto:disable

disable ACM for an app

USAGE
  $ heroku certs:auto:disable -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  disable ACM for an app

See code: src/commands/certs/auto/disable.ts

heroku certs:auto:enable

enable ACM status for an app

USAGE
  $ heroku certs:auto:enable -a <value> [--wait] [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
      --wait            watch ACM status and exit when complete

DESCRIPTION
  enable ACM status for an app

See code: src/commands/certs/auto/enable.ts

heroku certs:auto:refresh

refresh ACM for an app

USAGE
  $ heroku certs:auto:refresh -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  refresh ACM for an app

See code: src/commands/certs/auto/refresh.ts

heroku certs:generate DOMAIN

generate a key and a CSR or self-signed certificate

USAGE
  $ heroku certs:generate DOMAIN -a <value> [--selfsigned] [--keysize
    <value>] [--owner <value>] [--country <value>] [--area <value>] [--city
    <value>] [--subject <value>] [--now] [-r <value>]

ARGUMENTS
  DOMAIN  domain name to generate

FLAGS
  -a, --app=<value>      (required) app to run command against
  -r, --remote=<value>   git remote of app to use
      --area=<value>     sub-country area (state, province, etc.) of owner
      --city=<value>     city of owner
      --country=<value>  country of owner, as a two-letter ISO country code
      --keysize=<value>  RSA key size in bits (default: 2048)
      --now              do not prompt for any owner information
      --owner=<value>    name of organization certificate belongs to
      --selfsigned       generate a self-signed certificate instead of a CSR
      --subject=<value>  specify entire certificate subject

DESCRIPTION
  generate a key and a CSR or self-signed certificate

See code: src/commands/certs/generate.ts

heroku ci:config

display CI config vars

USAGE
  $ heroku ci:config [-a <value>] [-r <value>] [-s] [--json] [-p
    <value>]

FLAGS
  -a, --app=<value>       app to run command against
  -p, --pipeline=<value>  name of pipeline
  -r, --remote=<value>    git remote of app to use
  -s, --shell             output config vars in shell format
      --json              output config vars in json format

DESCRIPTION
  display CI config vars

EXAMPLES
  $ heroku ci:config --app murmuring-headland-14719 --json

See code: src/commands/ci/config/index.ts

heroku ci:config:get KEY

get a CI config var

USAGE
  $ heroku ci:config:get KEY [-h] [-a <value>] [-r <value>] [-p <value>]
    [-s]

ARGUMENTS
  KEY  name of the config var key

FLAGS
  -a, --app=<value>       app to run command against
  -h, --help              Show CLI help.
  -p, --pipeline=<value>  name of pipeline
  -r, --remote=<value>    git remote of app to use
  -s, --shell             output config var in shell format

DESCRIPTION
  get a CI config var

EXAMPLES
  $ heroku ci:config:get --pipeline=PIPELINE RAILS_ENV
      test

See code: src/commands/ci/config/get.ts

heroku ci:config:set

set CI config vars

USAGE
  $ heroku ci:config:set [-a <value>] [-r <value>] [-p <value>]

FLAGS
  -a, --app=<value>       app to run command against
  -p, --pipeline=<value>  name of pipeline
  -r, --remote=<value>    git remote of app to use

DESCRIPTION
  set CI config vars

EXAMPLES
  $ heroku ci:config:set --pipeline PIPELINE RAILS_ENV=test
      Setting test config vars... done
      RAILS_ENV: test

See code: src/commands/ci/config/set.ts

heroku ci:config:unset

unset CI config vars

USAGE
  $ heroku ci:config:unset [-a <value>] [-r <value>] [-p <value>]

FLAGS
  -a, --app=<value>       app to run command against
  -p, --pipeline=<value>  name of pipeline
  -r, --remote=<value>    git remote of app to use

DESCRIPTION
  unset CI config vars

EXAMPLES
  $ heroku ci:config:unset RAILS_ENV

See code: src/commands/ci/config/unset.ts

heroku ci:migrate-manifest

app-ci.json is deprecated. Run this command to migrate to app.json with an environments key.

USAGE
  $ heroku ci:migrate-manifest

DESCRIPTION
  app-ci.json is deprecated. Run this command to migrate to app.json with an
  environments key.

EXAMPLES
  $ heroku ci:migrate-manifest

See code: src/commands/ci/migrate-manifest.ts

heroku clients

list your OAuth clients

USAGE
  $ heroku clients [-j]

FLAGS
  -j, --json  output in json format

DESCRIPTION
  list your OAuth clients

See code: src/commands/clients/index.ts

heroku clients:create NAME REDIRECT_URI

create a new OAuth client

USAGE
  $ heroku clients:create NAME REDIRECT_URI [-j] [-s]

ARGUMENTS
  NAME          name of the OAuth client
  REDIRECT_URI  redirect URL of the OAuth client

FLAGS
  -j, --json   output in json format
  -s, --shell  output in shell format

DESCRIPTION
  create a new OAuth client

EXAMPLES
  $ heroku clients:create "Amazing" https://amazing-client.herokuapp.com/auth/heroku/callback

See code: src/commands/clients/create.ts

heroku clients:destroy ID

delete client by ID

USAGE
  $ heroku clients:destroy ID

ARGUMENTS
  ID  ID of the OAuth client

DESCRIPTION
  delete client by ID

See code: src/commands/clients/destroy.ts

heroku clients:rotate ID

rotate OAuth client secret

USAGE
  $ heroku clients:rotate ID [-j] [-s]

ARGUMENTS
  ID  ID of the OAuth client

FLAGS
  -j, --json   output in json format
  -s, --shell  output in shell format

DESCRIPTION
  rotate OAuth client secret

See code: src/commands/clients/rotate.ts

heroku clients:update ID

update OAuth client

USAGE
  $ heroku clients:update ID [-n <value>] [--url <value>]

ARGUMENTS
  ID  ID of the OAuth client

FLAGS
  -n, --name=<value>  change the client name
      --url=<value>   change the client redirect URL

DESCRIPTION
  update OAuth client

EXAMPLES
  $ heroku clients:update 3e304bda-d376-4278-bdea-6d6c08aa1359 --url https://amazing-client.herokuapp.com/auth/heroku/callback

See code: src/commands/clients/update.ts

heroku container

Use containers to build and deploy Heroku apps

USAGE
  $ heroku container

DESCRIPTION
  Use containers to build and deploy Heroku apps

See code: src/commands/container/index.ts

USAGE
  $ heroku container:login [-v]

FLAGS
  -v, --verbose

DESCRIPTION
  log in to Heroku Container Registry

See code: src/commands/container/login.ts

heroku container:logout

log out from Heroku Container Registry

USAGE
  $ heroku container:logout [-v]

FLAGS
  -v, --verbose

DESCRIPTION
  log out from Heroku Container Registry

See code: src/commands/container/logout.ts

heroku container:pull -a APP [-v] PROCESS_TYPE...

pulls an image from an app’s process type

USAGE
  $ heroku container:pull -a APP [-v] PROCESS_TYPE...

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
  -v, --verbose

DESCRIPTION
  pulls an image from an app's process type

EXAMPLES
    $ heroku container:pull web        # Pulls the web image from the app
    $ heroku container:pull web worker # Pulls both the web and worker images from the app
    $ heroku container:pull web:latest # Pulls the latest tag from the web image

See code: src/commands/container/pull.ts

heroku container:push

builds, then pushes Docker images to deploy your Heroku app

USAGE
  $ heroku container:push -a <value> [-v] [-R] [--arg <value>]
    [--context-path <value>] [-r <value>]

FLAGS
  -R, --recursive             pushes Dockerfile.<process> found in current and
                              subdirectories
  -a, --app=<value>           (required) app to run command against
  -r, --remote=<value>        git remote of app to use
  -v, --verbose
      --arg=<value>           set build-time variables
      --context-path=<value>  path to use as build context (defaults to
                              Dockerfile dir)

DESCRIPTION
  builds, then pushes Docker images to deploy your Heroku app

EXAMPLES
  $ heroku container:push web                          # Pushes Dockerfile to web process type

  $ heroku container:push worker                       # Pushes Dockerfile to worker process type

  $ heroku container:push web worker --recursive       # Pushes Dockerfile.web and Dockerfile.worker

  $ heroku container:push --recursive                  # Pushes Dockerfile.*

  $ heroku container:push web --arg ENV=live,HTTPS=on  # Build-time variables

  $ heroku container:push --recursive --context-path . # Pushes Dockerfile.* using current dir as build context

See code: src/commands/container/push.ts

heroku container:release

Releases previously pushed Docker images to your Heroku app

USAGE
  $ heroku container:release

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
  -v, --verbose

DESCRIPTION
  Releases previously pushed Docker images to your Heroku app

EXAMPLES
    heroku container:release web        # Releases the previously pushed web process type
    heroku container:release web worker # Releases the previously pushed web and worker process types

See code: src/commands/container/release.ts

heroku container:rm -a APP [-v] PROCESS_TYPE...

remove the process type from your app

USAGE
  $ heroku container:rm -a APP [-v] PROCESS_TYPE...

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  remove the process type from your app

EXAMPLES
    heroku container:rm web        # Destroys the web container
    heroku container:rm web worker # Destroys the web and worker containers

See code: src/commands/container/rm.ts

heroku container:run -a APP [-v] PROCESS_TYPE...

builds, then runs the docker image locally

USAGE
  $ heroku container:run -a APP [-v] PROCESS_TYPE...

FLAGS
  -a, --app=<value>     (required) app to run command against
  -p, --port=<value>    [default: 5000] port the app will run on
  -r, --remote=<value>  git remote of app to use
  -v, --verbose

DESCRIPTION
  builds, then runs the docker image locally

EXAMPLES
    $ heroku container:pull web        # Pulls the web image from the app
    $ heroku container:pull web worker # Pulls both the web and worker images from the app
    $ heroku container:pull web:latest # Pulls the latest tag from the web image

See code: src/commands/container/run.ts

heroku domains

list domains for an app

USAGE
  $ heroku domains -a <value> [-h] [-r <value>] [-j] [--columns
    <value> | -x] [--sort <value>] [--filter <value>] [--output csv|json|yaml |
    | [--csv | ]] [--no-header | ]

FLAGS
  -a, --app=<value>      (required) app to run command against
  -h, --help             Show CLI help.
  -j, --json             output in json format
  -r, --remote=<value>   git remote of app to use
  -x, --extended         show extra columns
      --columns=<value>  only show provided columns (comma-separated)
      --csv              output is csv format [alias: --output=csv]
      --filter=<value>   filter property by partial string matching, ex:
                         name=foo
      --no-header        hide table header from output
      --output=<option>  output in a more machine friendly format
                         <options: csv|json|yaml>
      --sort=<value>     property to sort by (prepend '-' for descending)

DESCRIPTION
  list domains for an app

EXAMPLES
  $ heroku domains
  === example Heroku Domain
  example-xxxxxxxxxxxx.herokuapp.com
  === example Custom Domains
  Domain Name      DNS Record Type  DNS Target
  www.example.com  CNAME            www.example.herokudns.com

  $ heroku domains --filter 'Domain Name=www.example.com'

See code: src/commands/domains/index.ts

heroku domains:clear

remove all domains from an app

USAGE
  $ heroku domains:clear -a <value> [-h] [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -h, --help            Show CLI help.
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  remove all domains from an app

EXAMPLES
  $ heroku domains:clear

See code: src/commands/domains/clear.ts

heroku domains:remove HOSTNAME

remove a domain from an app

USAGE
  $ heroku domains:remove HOSTNAME -a <value> [-h] [-r <value>]

ARGUMENTS
  HOSTNAME  unique identifier of the domain or full hostname

FLAGS
  -a, --app=<value>     (required) app to run command against
  -h, --help            Show CLI help.
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  remove a domain from an app

EXAMPLES
  $ heroku domains:remove www.example.com

See code: src/commands/domains/remove.ts

heroku domains:update HOSTNAME

update a domain to use a different SSL certificate on an app

USAGE
  $ heroku domains:update HOSTNAME -a <value> --cert <value> [-h] [-r
    <value>]

ARGUMENTS
  HOSTNAME  unique identifier of the domain or full hostname

FLAGS
  -a, --app=<value>     (required) app to run command against
  -h, --help            Show CLI help.
  -r, --remote=<value>  git remote of app to use
      --cert=<value>    (required) the name or id of the certificate you want to
                        use for this domain

DESCRIPTION
  update a domain to use a different SSL certificate on an app

EXAMPLES
  $ heroku domains:update www.example.com --cert mycert

See code: src/commands/domains/update.ts

heroku domains:wait [HOSTNAME]

wait for domain to be active for an app

USAGE
  $ heroku domains:wait [HOSTNAME] -a <value> [-h] [-r <value>]

ARGUMENTS
  HOSTNAME  unique identifier of the domain or full hostname

FLAGS
  -a, --app=<value>     (required) app to run command against
  -h, --help            Show CLI help.
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  wait for domain to be active for an app

See code: src/commands/domains/wait.ts

heroku drains:remove URL

removes a log drain from an app

USAGE
  $ heroku drains:remove URL -a <value> [-r <value>]

ARGUMENTS
  URL  URL of the log drain

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  removes a log drain from an app

EXAMPLES
  drains:remove [URL|TOKEN]

See code: src/commands/drains/remove.ts

heroku features

list available app features

USAGE
  $ heroku features -a <value> [-r <value>] [--json]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
      --json            output in json format

DESCRIPTION
  list available app features

See code: src/commands/features/index.ts

heroku features:disable FEATURE

disables an app feature

USAGE
  $ heroku features:disable FEATURE -a <value> [-r <value>]

ARGUMENTS
  FEATURE  unique identifier or name of the app feature

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  disables an app feature

See code: src/commands/features/disable.ts

heroku features:enable FEATURE

enables an app feature

USAGE
  $ heroku features:enable FEATURE -a <value> [-r <value>]

ARGUMENTS
  FEATURE  unique identifier or name of the app feature

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  enables an app feature

See code: src/commands/features/enable.ts

heroku features:info FEATURE

display information about a feature

USAGE
  $ heroku features:info FEATURE -a <value> [-r <value>] [--json]

ARGUMENTS
  FEATURE  unique identifier or name of the app feature

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
      --json            output in json format

DESCRIPTION
  display information about a feature

See code: src/commands/features/info.ts

heroku local:version

display node-foreman version

USAGE
  $ heroku local:version

DESCRIPTION
  display node-foreman version

See code: src/commands/local/version.ts

heroku maintenance

display the current maintenance status of app

USAGE
  $ heroku maintenance -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  display the current maintenance status of app

See code: src/commands/maintenance/index.ts

heroku maintenance:off

take the app out of maintenance mode

USAGE
  $ heroku maintenance:off -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  take the app out of maintenance mode

See code: src/commands/maintenance/off.ts

heroku maintenance:on

put the app into maintenance mode

USAGE
  $ heroku maintenance:on -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  put the app into maintenance mode

See code: src/commands/maintenance/on.ts

heroku members

list members of a team

USAGE
  $ heroku members -t <value> [-r <value>] [--pending] [--json]

FLAGS
  -r, --role=<value>  filter by role
  -t, --team=<value>  (required) team to use
      --json          output in json format
      --pending       filter by pending team invitations

DESCRIPTION
  list members of a team

See code: src/commands/members/index.ts

heroku members:remove

removes a user from a team

USAGE
  $ heroku members:remove -t <value>

FLAGS
  -t, --team=<value>  (required) team to use

DESCRIPTION
  removes a user from a team

See code: src/commands/members/remove.ts

heroku notifications

display notifications

USAGE
  $ heroku notifications [-a <value>] [-r <value>] [--all] [--json] [--read]

FLAGS
  -a, --app=<value>     app to run command against
  -r, --remote=<value>  git remote of app to use
      --all             view all notifications (not just the ones for the
                        current app)
      --json            output in json format
      --read            show notifications already read

DESCRIPTION
  display notifications

See code: src/commands/notifications/index.ts

heroku pg:backups

list database backups

USAGE
  $ heroku pg:backups -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  list database backups

See code: src/commands/pg/backups/index.ts

heroku pg:backups:cancel [BACKUP_ID]

cancel an in-progress backup or restore (default newest)

USAGE
  $ heroku pg:backups:cancel [BACKUP_ID] -a <value> [-r <value>]

ARGUMENTS
  BACKUP_ID  ID of the backup. If omitted, we use the last unfinished backup ID.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  cancel an in-progress backup or restore (default newest)

See code: src/commands/pg/backups/cancel.ts

heroku pg:backups:capture [DATABASE]

capture a new backup

USAGE
  $ heroku pg:backups:capture [DATABASE] -a <value> [--wait-interval <value>]
    [-v] [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>            (required) app to run command against
  -r, --remote=<value>         git remote of app to use
  -v, --verbose
  --wait-interval=<value>

DESCRIPTION
  capture a new backup

See code: src/commands/pg/backups/capture.ts

heroku pg:backups:delete BACKUP_ID

delete a backup

USAGE
  $ heroku pg:backups:delete BACKUP_ID -a <value> [-c <value>] [-r <value>]

ARGUMENTS
  BACKUP_ID  ID of the backup

FLAGS
  -a, --app=<value>      (required) app to run command against
  -c, --confirm=<value>
  -r, --remote=<value>   git remote of app to use

DESCRIPTION
  delete a backup

EXAMPLES
  $ heroku pg:backup:delete --app APP_ID BACKUP_ID

See code: src/commands/pg/backups/delete.ts

heroku pg:backups:download [BACKUP_ID]

downloads database backup

USAGE
  $ heroku pg:backups:download [BACKUP_ID] -a <value> [-o <value>] [-r <value>]

ARGUMENTS
  BACKUP_ID  ID of the backup. If omitted, we use the last backup ID.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -o, --output=<value>  location to download to. Defaults to latest.dump
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  downloads database backup

See code: src/commands/pg/backups/download.ts

heroku pg:backups:info [BACKUP_ID]

get information about a specific backup

USAGE
  $ heroku pg:backups:info [BACKUP_ID] -a <value> [-r <value>]

ARGUMENTS
  BACKUP_ID  ID of the backup. If omitted, we use the last backup ID.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  get information about a specific backup

See code: src/commands/pg/backups/info.ts

heroku pg:backups:restore [BACKUP] [DATABASE]

restore a backup (default latest) to a database

USAGE
  $ heroku pg:backups:restore [BACKUP] [DATABASE] -a <value> [--wait-interval
    <value>] [-e <value>] [-v] [-c <value>] [-r <value>]

ARGUMENTS
  BACKUP    URL or backup ID from another app
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>            (required) app to run command against
  -c, --confirm=<value>
  -e, --extensions=<value>     comma-separated list of extensions to pre-install
                               in the default
                               public schema or an optional custom schema
                               (for example: hstore or myschema.hstore)
  -r, --remote=<value>         git remote of app to use
  -v, --verbose
      --wait-interval=<value>  [default: 3]

DESCRIPTION
  restore a backup (default latest) to a database

EXAMPLES
  # Basic Restore from Backup ID

    $ heroku pg:backups:restore b101 DATABASE_URL --app my-heroku-app

  # Restore from Another App

    $ heroku pg:backups:restore example-app::b101 DATABASE_URL --app \
      my-heroku-app

  # Restore from a Public URL

    $ heroku pg:backups:restore \
      'https://s3.amazonaws.com/my-bucket/mydb.dump' DATABASE_URL --app \
      my-heroku-app

  # Verbose Output

    $ heroku pg:backups:restore b101 DATABASE_URL --app my-heroku-app \
      --verbose

  # Restore with Confirmation Prompt

    $ heroku pg:backups:restore b101 DATABASE_URL --app my-heroku-app \
      --confirm my-heroku-app

  # Restore with a Specific Database Name

    $ heroku pg:backups:restore b101 HEROKU_POSTGRESQL_PINK --app \
      my-heroku-app

See code: src/commands/pg/backups/restore.ts

heroku pg:backups:schedule [DATABASE]

schedule daily backups for given database

USAGE
  $ heroku pg:backups:schedule [DATABASE] --at <value> -a <value> [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
      --at=<value>      (required) at a specific (24h) hour in the given
                        timezone. Defaults to UTC. --at '[HOUR]:00 [TIMEZONE]'

DESCRIPTION
  schedule daily backups for given database

See code: src/commands/pg/backups/schedule.ts

heroku pg:backups:schedules

list backup schedule

USAGE
  $ heroku pg:backups:schedules -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  list backup schedule

See code: src/commands/pg/backups/schedules.ts

heroku pg:backups:unschedule [DATABASE]

stop daily backups

USAGE
  $ heroku pg:backups:unschedule [DATABASE] -a <value> [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use a random database attached to the app.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  stop daily backups

See code: src/commands/pg/backups/unschedule.ts

heroku pg:backups:url [BACKUP_ID]

get secret but publicly accessible URL of a backup

USAGE
  $ heroku pg:backups:url [BACKUP_ID] -a <value> [-r <value>]

ARGUMENTS
  BACKUP_ID  ID of the backup. If omitted, we use the last backup ID.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  get secret but publicly accessible URL of a backup

See code: src/commands/pg/backups/url.ts

heroku pg:connection-pooling:attach [DATABASE]

add an attachment to a database using connection pooling

USAGE
  $ heroku pg:connection-pooling:attach [DATABASE] -a <value> [--as <value>] [-r
  <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
      --as=<value>      name for add-on attachment

DESCRIPTION
  add an attachment to a database using connection pooling

EXAMPLES
  $ heroku pg:connection-pooling:attach postgresql-something-12345

See code: src/commands/pg/connection-pooling/attach.ts

heroku pg:credentials [DATABASE]

show information on credentials in the database

USAGE
  $ heroku pg:credentials [DATABASE] -a <value> [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  show information on credentials in the database

See code: src/commands/pg/credentials.ts

heroku pg:credentials:create [DATABASE]

create credential within database

USAGE
  $ heroku pg:credentials:create [DATABASE] -n <value> -a <value> [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -n, --name=<value>    (required) name of the new credential within the
                        database
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  create credential within database
  Example:

  heroku pg:credentials:create postgresql-something-12345 --name new-cred-name

See code: src/commands/pg/credentials/create.ts

heroku pg:credentials:destroy [DATABASE]

destroy credential within database

USAGE
  $ heroku pg:credentials:destroy [DATABASE] -n <value> -a <value> [-c <value>] [-r
    <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>      (required) app to run command against
  -c, --confirm=<value>
  -n, --name=<value>     (required) unique identifier for the credential
  -r, --remote=<value>   git remote of app to use

DESCRIPTION
  destroy credential within database

EXAMPLES
  $ heroku pg:credentials:destroy postgresql-transparent-56874 --name cred-name -a woodstock-production

See code: src/commands/pg/credentials/destroy.ts

heroku pg:credentials:repair-default [DATABASE]

repair the permissions of the default credential within database

USAGE
  $ heroku pg:credentials:repair-default [DATABASE] -a <value> [-c <value>] [-r
  <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>      (required) app to run command against
  -c, --confirm=<value>
  -r, --remote=<value>   git remote of app to use

DESCRIPTION
  repair the permissions of the default credential within database

EXAMPLES
  $ heroku pg:credentials:repair-default postgresql-something-12345

See code: src/commands/pg/credentials/repair-default.ts

heroku pg:credentials:rotate [DATABASE]

rotate the database credentials

USAGE
  $ heroku pg:credentials:rotate [DATABASE] -a <value> [--all | -n <value>] [-c
    <value>] [--force] [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>      (required) app to run command against
  -c, --confirm=<value>
  -n, --name=<value>     which credential to rotate (default credentials if not
                         specified and --all is not used)
  -r, --remote=<value>   git remote of app to use
      --all              rotate all credentials
      --force            forces rotating the targeted credentials

DESCRIPTION
  rotate the database credentials

See code: src/commands/pg/credentials/rotate.ts

heroku pg:credentials:url [DATABASE]

show information on a database credential

USAGE
  $ heroku pg:credentials:url [DATABASE] -a <value> [-n <value>] [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -n, --name=<value>    [default: default] which credential to show (default
                        credentials if not specified)
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  show information on a database credential

See code: src/commands/pg/credentials/url.ts

heroku pg:diagnose [DATABASE|REPORT_ID]

run or view diagnostics report

USAGE
  $ heroku pg:diagnose [DATABASE|REPORT_ID] -a <value> [--json] [-r
    <value>]

ARGUMENTS
  DATABASE|REPORT_ID  config var exposed to the owning app containing the
                      database URL or the report ID

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
      --json            format output as JSON

DESCRIPTION
  run or view diagnostics report
  defaults to DATABASE_URL database if no DATABASE is specified
  if REPORT_ID is specified instead, a previous report is displayed

See code: src/commands/pg/diagnose.ts

heroku pg:links [DATABASE]

lists all databases and information on link

USAGE
  $ heroku pg:links [DATABASE] -a <value> [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  lists all databases and information on link

See code: src/commands/pg/links/index.ts

heroku pg:links:create REMOTE DATABASE

create a link between data stores

USAGE
  $ heroku pg:links:create REMOTE DATABASE -a <value> [--as <value>] [-r
    <value>]

ARGUMENTS
  REMOTE    config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::`
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::`

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
      --as=<value>      name of link to create

DESCRIPTION
  create a link between data stores
  Example:
  heroku pg:links:create HEROKU_REDIS_RED HEROKU_POSTGRESQL_CERULEAN

See code: src/commands/pg/links/create.ts

heroku pg:links:destroy DATABASE LINK

destroys a link between data stores

USAGE
  $ heroku pg:links:destroy DATABASE LINK -a <value> [-c <value>] [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::`
  LINK      name of the linked data store

FLAGS
  -a, --app=<value>      (required) app to run command against
  -c, --confirm=<value>
  -r, --remote=<value>   git remote of app to use

DESCRIPTION
  destroys a link between data stores

EXAMPLES
  $ heroku pg:links:destroy HEROKU_POSTGRESQL_CERULEAN redis-symmetrical-100

See code: src/commands/pg/links/destroy.ts

heroku pg:maintenance [DATABASE]

show current maintenance information

USAGE
  $ heroku pg:maintenance [DATABASE] -a <value> [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  show current maintenance information

See code: src/commands/pg/maintenance/index.ts

heroku pg:maintenance:run [DATABASE]

start maintenance

USAGE
  $ heroku pg:maintenance:run [DATABASE] -a <value> [-f] [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -f, --force
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  start maintenance

See code: src/commands/pg/maintenance/run.ts

heroku pg:maintenance:window WINDOW [DATABASE]

Set weekly maintenance window.

USAGE
  $ heroku pg:maintenance:window WINDOW [DATABASE] -a <value> [-r <value>]

ARGUMENTS
  WINDOW    timestamp of the maintenance window
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  Set weekly maintenance window.
  All times are in UTC.


EXAMPLES
  $ heroku pg:maintenance:window "Sunday 06:00" postgres-slippery-100

See code: src/commands/pg/maintenance/window.ts

heroku pg:settings [DATABASE]

show your current database settings

USAGE
  $ heroku pg:settings [DATABASE] -a <value> [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  show your current database settings

See code: src/commands/pg/settings/index.ts

heroku pg:settings:auto-explain [DATABASE] [VALUE]

Automatically log execution plans of queries without running EXPLAIN by hand.

USAGE
  $ heroku pg:settings:auto-explain [DATABASE...] [VALUE...] -a <value> [-r
  <value>]

ARGUMENTS
  DATABASE...  config var containing the connection string, unique name, ID, or
               alias of the database. To access another app's database, prepend
               the app name to the config var or alias with `APP_NAME::` . If
               omitted, we use DATABASE_URL.
  VALUE...     boolean indicating if execution plans of queries will be logged
               for future connections

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  Automatically log execution plans of queries without running EXPLAIN by hand.
  The auto_explain module is loaded at session-time so existing connections will
  not be logged.
  Restart your Heroku app and/or restart existing connections for logging to
  start taking place.

See code: src/commands/pg/settings/auto-explain.ts

heroku pg:settings:auto-explain:log-analyze [DATABASE] [VALUE]

Shows actual run times on the execution plan.

USAGE
  $ heroku pg:settings:auto-explain:log-analyze [DATABASE] [VALUE] -a <value>
  [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.
  VALUE     boolean indicating if execution plans get logged

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  Shows actual run times on the execution plan.
  This is equivalent to calling EXPLAIN ANALYZE.

  WARNING: EXPLAIN ANALYZE will be run on ALL queries, not just logged queries.
  This can cause significant performance impacts to your database and should be
  used with caution.

See code: src/commands/pg/settings/auto-explain/log-analyze.ts

heroku pg:settings:auto-explain:log-buffers [DATABASE] [VALUE]

Includes buffer usage statistics when execution plans are logged.

USAGE
  $ heroku pg:settings:auto-explain:log-buffers [DATABASE] [VALUE] -a <value>
  [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.
  VALUE     boolean indicating if the database has buffer statistics enabled

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  Includes buffer usage statistics when execution plans are logged.
  This is equivalent to calling EXPLAIN BUFFERS and can only be used in
  conjunction with pg:settings:auto-explain:log-analyze turned on.

See code: src/commands/pg/settings/auto-explain/log-buffers.ts

heroku pg:settings:auto-explain:log-format [DATABASE] [VALUE]

selects the EXPLAIN output format to be used

USAGE
  $ heroku pg:settings:auto-explain:log-format [DATABASE] [VALUE] -a <value> [-r
  <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.
  VALUE     (text|json|yaml|xml) format of the log output
            <options: text|json|yaml|xml>

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  selects the EXPLAIN output format to be used
  The allowed values are text, xml, json, and yaml. The default is text.

See code: src/commands/pg/settings/auto-explain/log-format.ts

heroku pg:settings:auto-explain:log-min-duration [DATABASE] [VALUE]

Sets the minimum execution time in milliseconds for a statement’s plan to be logged.

USAGE
  $ heroku pg:settings:auto-explain:log-min-duration [DATABASE] [VALUE] -a
  <value> [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.
  VALUE     minimum duration in milliseconds for queries before logging
            execution plans. A value of -1 disables it. A value of 0 logs all
            query execution plans.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  Sets the minimum execution time in milliseconds for a statement's plan to be
  logged.
  Setting this value to 0 will log all queries. Setting this value to -1 will
  disable logging entirely.

See code: src/commands/pg/settings/auto-explain/log-min-duration.ts

heroku pg:settings:auto-explain:log-nested-statements [DATABASE] [VALUE]

Nested statements are included in the execution plan’s log.

USAGE
  $ heroku pg:settings:auto-explain:log-nested-statements [DATABASE] [VALUE] -a
  <value> [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.
  VALUE     boolean indicating if execution plan logs include nested statements

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  Nested statements are included in the execution plan's log.

See code: src/commands/pg/settings/auto-explain/log-nested-statements.ts

heroku pg:settings:auto-explain:log-triggers [DATABASE] [VALUE]

Includes trigger execution statistics in execution plan logs.

USAGE
  $ heroku pg:settings:auto-explain:log-triggers [DATABASE] [VALUE] -a <value>
  [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.
  VALUE     boolean indicating if the database has trigger execution statistics
            enabled

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  Includes trigger execution statistics in execution plan logs.
  This parameter can only be used in conjunction with
  pg:settings:auto-explain:log-analyze turned on.

See code: src/commands/pg/settings/auto-explain/log-triggers.ts

heroku pg:settings:auto-explain:log-verbose [DATABASE] [VALUE]

Include verbose details in execution plans.

USAGE
  $ heroku pg:settings:auto-explain:log-verbose [DATABASE] [VALUE] -a <value>
  [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.
  VALUE     boolean indicating if the database has verbose execution plan
            logging enabled

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  Include verbose details in execution plans.
  This is equivalent to calling EXPLAIN VERBOSE.

See code: src/commands/pg/settings/auto-explain/log-verbose.ts

heroku pg:settings:explain-data-connector-details [DATABASE] [VALUE]

displays stats on replication slots on your database, the default value is “off”

USAGE
  $ heroku pg:settings:explain-data-connector-details [DATABASE] [VALUE] -a
  <value> [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.
  VALUE     boolean indicating if data replication slot details get logged

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  displays stats on replication slots on your database, the default value is
  "off"

See code: src/commands/pg/settings/explain-data-connector-details.ts

heroku pg:settings:log-connections [DATABASE] [VALUE]

Controls whether a log message is produced when a login attempt is made. Default is true.

USAGE
  $ heroku pg:settings:log-connections [DATABASE] [VALUE] -a <value> [-r
  <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.
  VALUE     boolean indicating if database login attempts get logged

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  Controls whether a log message is produced when a login attempt is made.
  Default is true.
  Setting log_connections to false stops emitting log messages for all attempts
  to login to the database.

See code: src/commands/pg/settings/log-connections.ts

heroku pg:settings:log-lock-waits [DATABASE] [VALUE]

Controls whether a log message is produced when a session waits longer than the deadlock_timeout to acquire a lock. deadlock_timeout is set to 1 second

USAGE
  $ heroku pg:settings:log-lock-waits [DATABASE] [VALUE] -a <value> [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.
  VALUE     boolean indicating if a message gets logged when a session waits
            longer than the deadlock_timeout to acquire a lock

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  Controls whether a log message is produced when a session waits longer than
  the deadlock_timeout to acquire a lock. deadlock_timeout is set to 1 second
  Delays due to lock contention occur when multiple transactions are trying to
  access the same resource at the same time.
  Applications and their query patterns should try to avoid changes to many
  different tables within the same transaction.

See code: src/commands/pg/settings/log-lock-waits.ts

heroku pg:settings:log-min-duration-statement [DATABASE] [VALUE]

The duration of each completed statement will be logged if the statement completes after the time specified by VALUE.

USAGE
  $ heroku pg:settings:log-min-duration-statement [DATABASE] [VALUE] -a <value>
  [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.
  VALUE     milliseconds to wait for a statement to complete before logging it

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  The duration of each completed statement will be logged if the statement
  completes after the time specified by VALUE.
  VALUE needs to specified as a whole number, in milliseconds.
  Setting log_min_duration_statement to zero prints all statement durations and
  -1 will disable logging statement durations.

See code: src/commands/pg/settings/log-min-duration-statement.ts

heroku pg:settings:log-min-error-statement [DATABASE] [VALUE]

log-min-error-statement controls the logging of SQL statements that cause an error at a specified severity level.

USAGE
  $ heroku pg:settings:log-min-error-statement [DATABASE] [VALUE] -a <value> [-r
  <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.
  VALUE     (error|log|fatal|panic)

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  log-min-error-statement controls the logging of SQL statements that cause an
  error at a specified severity level.
  This setting is useful to prevent logging SQL queries that might contain
  sensitive information.
  Use this setting to prevent logging SQL queries that contain sensitive
  information. Default is "error".

See code: src/commands/pg/settings/log-min-error-statement.ts

heroku pg:settings:log-statement [DATABASE] [VALUE]

log_statement controls which SQL statements are logged.

USAGE
  $ heroku pg:settings:log-statement [DATABASE] [VALUE] -a <value> [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.
  VALUE     (none|ddl|mod|all) type of SQL statements to log
            <options: none|ddl|mod|all>

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  log_statement controls which SQL statements are logged.
  Valid values for VALUE:
  none - No statements are logged
  ddl  - All data definition statements, such as CREATE, ALTER and DROP will be
  logged
  mod  - Includes all statements from ddl as well as data-modifying statements
  such as INSERT, UPDATE, DELETE, TRUNCATE, COPY
  all  - All statements are logged

See code: src/commands/pg/settings/log-statement.ts

heroku pg:settings:track-functions [DATABASE] [VALUE]

track_functions controls tracking of function call counts and time used. Default is none.

USAGE
  $ heroku pg:settings:track-functions [DATABASE] [VALUE] -a <value> [-r
  <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.
  VALUE     (none|pl|all) function type to track
            <options: none|pl|all>

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  track_functions controls tracking of function call counts and time used.
  Default is none.
  Valid values for VALUE:
  none - No functions are tracked (default)
  pl   - Only procedural language functions are tracked
  all  - All functions, including SQL and C language functions, are tracked.
  Simple SQL-language that are inlined are not tracked

See code: src/commands/pg/settings/track-functions.ts

For an Essential-* plan, this command upgrades the database’s PostgreSQL version. For a Standard-tier and higher plan, this command unfollows the leader database before upgrading the PostgreSQL version.

USAGE
  $ heroku pg:upgrade [DATABASE] -a <value> [-c <value>] [-v <value>]
    [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>      (required) app to run command against
  -c, --confirm=<value>
  -r, --remote=<value>   git remote of app to use
  -v, --version=<value>  PostgreSQL version to upgrade to

DESCRIPTION
  For an Essential-* plan, this command upgrades the database's PostgreSQL
  version. For a Standard-tier and higher plan, this command unfollows the
  leader database before upgrading the PostgreSQL version.
  To upgrade to another PostgreSQL version, use pg:copy instead

See code: src/commands/pg/upgrade.ts

heroku pg:vacuum-stats [DATABASE]

show dead rows and whether an automatic vacuum is expected to be triggered

USAGE
  $ heroku pg:vacuum-stats [DATABASE] -a <value> [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use DATABASE_URL.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  show dead rows and whether an automatic vacuum is expected to be triggered

See code: src/commands/pg/vacuum-stats.ts

heroku pg:wait [DATABASE]

blocks until database is available

USAGE
  $ heroku pg:wait [DATABASE] -a <value> [--wait-interval <value>]
    [--no-notify] [-r <value>]

ARGUMENTS
  DATABASE  config var containing the connection string, unique name, ID, or
            alias of the database. To access another app's database, prepend the
            app name to the config var or alias with `APP_NAME::` . If omitted,
            we use all databases.

FLAGS
  -a, --app=<value>            (required) app to run command against
  -r, --remote=<value>         git remote of app to use
      --no-notify              do not show OS notification
      --wait-interval=<value>  how frequently to poll in seconds (to avoid rate
                               limiting)

DESCRIPTION
  blocks until database is available

See code: src/commands/pg/wait.ts

heroku pipelines

list pipelines you have access to

USAGE
  $ heroku pipelines [--json]

FLAGS
  --json  output in json format

DESCRIPTION
  list pipelines you have access to

EXAMPLES
  $ heroku pipelines

See code: src/commands/pipelines/index.ts

heroku pipelines:add PIPELINE

add this app to a pipeline

USAGE
  $ heroku pipelines:add PIPELINE -a <value> [-r <value>] [-s <value>]

ARGUMENTS
  PIPELINE  name of pipeline

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
  -s, --stage=<value>   stage of first app in pipeline

DESCRIPTION
  add this app to a pipeline
  The app and pipeline names must be specified.
  The stage of the app will be guessed based on its name if not specified.

EXAMPLES
  $ heroku pipelines:add my-pipeline -a my-app -s production

See code: src/commands/pipelines/add.ts

heroku pipelines:connect NAME

connect a GitHub repo to an existing pipeline

USAGE
  $ heroku pipelines:connect NAME -r <value>

ARGUMENTS
  NAME  name of pipeline

FLAGS
  -r, --repo=<value>  (required) the GitHub repository to connect to

DESCRIPTION
  connect a GitHub repo to an existing pipeline

EXAMPLES
  $ heroku pipelines:connect my-pipeline -r githuborg/reponame

See code: src/commands/pipelines/connect.ts

heroku pipelines:create [NAME]

create a new pipeline

USAGE
  $ heroku pipelines:create [NAME] -a <value> [-r <value>] [-s <value>] [-t
    <value>]

ARGUMENTS
  NAME  name of pipeline (defaults to basename of the app)

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
  -s, --stage=<value>   stage of first app in pipeline
  -t, --team=<value>    the team which will own the apps

DESCRIPTION
  create a new pipeline
  An existing app must be specified as the first app in the pipeline.
  The pipeline name will be inferred from the app name if not specified.
  The stage of the app will be guessed based on its name if not specified.
  The pipeline owner will be the user creating the pipeline if not specified
  with -t for teams or -o for orgs.

EXAMPLES
  $ heroku pipelines:create -a my-app-staging

  $ heroku pipelines:create my-pipeline -a my-app-staging

See code: src/commands/pipelines/create.ts

heroku pipelines:destroy PIPELINE

destroy a pipeline

USAGE
  $ heroku pipelines:destroy PIPELINE

ARGUMENTS
  PIPELINE  name of pipeline

DESCRIPTION
  destroy a pipeline

EXAMPLES
  $ heroku pipelines:destroy my-pipeline

See code: src/commands/pipelines/destroy.ts

heroku pipelines:diff

compares the latest release of this app to its downstream app(s)

USAGE
  $ heroku pipelines:diff -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  compares the latest release of this app to its downstream app(s)

EXAMPLES
  $ heroku pipelines:diff -a my-app-staging

See code: src/commands/pipelines/diff.ts

heroku pipelines:info PIPELINE

show list of apps in a pipeline

USAGE
  $ heroku pipelines:info PIPELINE [--json]

ARGUMENTS
  PIPELINE  pipeline to show list of apps for

FLAGS
  --json  output in json format

DESCRIPTION
  show list of apps in a pipeline

EXAMPLES
  $ heroku pipelines:info my-pipeline

See code: src/commands/pipelines/info.ts

heroku pipelines:open PIPELINE

open a pipeline in dashboard

USAGE
  $ heroku pipelines:open PIPELINE

ARGUMENTS
  PIPELINE  name of pipeline

DESCRIPTION
  open a pipeline in dashboard

EXAMPLES
  $ heroku pipelines:open my-pipeline

See code: src/commands/pipelines/open.ts

heroku pipelines:promote

promote the latest release of this app to its downstream app(s)

USAGE
  $ heroku pipelines:promote -a <value> [-r <value>] [-t <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
  -t, --to=<value>      comma separated list of apps to promote to

DESCRIPTION
  promote the latest release of this app to its downstream app(s)

EXAMPLES
  $ heroku pipelines:promote -a my-app-staging

See code: src/commands/pipelines/promote.ts

heroku pipelines:remove

remove this app from its pipeline

USAGE
  $ heroku pipelines:remove -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  remove this app from its pipeline

EXAMPLES
  $ heroku pipelines:remove -a my-app

See code: src/commands/pipelines/remove.ts

heroku pipelines:rename PIPELINE NAME

rename a pipeline

USAGE
  $ heroku pipelines:rename PIPELINE NAME

ARGUMENTS
  PIPELINE  current name of pipeline
  NAME      new name of pipeline

DESCRIPTION
  rename a pipeline

EXAMPLES
  $ heroku pipelines:rename my-pipeline new-pipeline-name

See code: src/commands/pipelines/rename.ts

heroku pipelines:setup [NAME] [REPO]

bootstrap a new pipeline with common settings and create a production and staging app (requires a fully formed app.json in the repo)

USAGE
  $ heroku pipelines:setup [NAME] [REPO] [-t <value>] [-y]

ARGUMENTS
  NAME  name of pipeline
  REPO  a GitHub repository to connect the pipeline to

FLAGS
  -t, --team=<value>  the team to assign pipeline ownership to (defaults to
                      current user)
  -y, --yes           accept all default settings without prompting

DESCRIPTION
  bootstrap a new pipeline with common settings and create a production and
  staging app (requires a fully formed app.json in the repo)

EXAMPLES
  $ heroku pipelines:setup my-pipeline githuborg/reponame -t my-team

See code: src/commands/pipelines/setup.ts

heroku pipelines:transfer OWNER

transfer ownership of a pipeline

USAGE
  $ heroku pipelines:transfer OWNER -p <value> [-c <value>]

ARGUMENTS
  OWNER  the owner to transfer the pipeline to

FLAGS
  -c, --confirm=<value>
  -p, --pipeline=<value>  (required) name of pipeline

DESCRIPTION
  transfer ownership of a pipeline

EXAMPLES
  $ heroku pipelines:transfer admin@example.com -p my-pipeline

  $ heroku pipelines:transfer admin-team -p my-pipeline

See code: src/commands/pipelines/transfer.ts

heroku pipelines:update

update the app’s stage in a pipeline

USAGE
  $ heroku pipelines:update -a <value> -s <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
  -s, --stage=<value>   (required) new stage of app

DESCRIPTION
  update the app's stage in a pipeline

EXAMPLES
  $ heroku pipelines:update -s staging -a my-app

See code: src/commands/pipelines/update.ts

heroku plugins

List installed plugins.

USAGE
  $ heroku plugins [--core]

FLAGS
  --core  Show core plugins.

DESCRIPTION
  List installed plugins.

EXAMPLES
  $ heroku plugins

See code: @oclif/plugin-plugins

heroku plugins:inspect PLUGIN...

Displays installation properties of a plugin.

USAGE
  $ heroku plugins:inspect PLUGIN...

ARGUMENTS
  PLUGIN...  [default: .] Plugin to inspect.

FLAGS
  -h, --help     Show CLI help.
  -v, --verbose

GLOBAL FLAGS
  --json  Format output as json.

DESCRIPTION
  Displays installation properties of a plugin.

EXAMPLES
  $ heroku plugins:inspect myplugin

See code: @oclif/plugin-plugins

heroku plugins:install PLUGIN...

Installs a plugin into the CLI.

USAGE
  $ heroku plugins:install PLUGIN...

ARGUMENTS
  PLUGIN...  Plugin to install.

FLAGS
  -f, --force    Run yarn install with force flag.
  -h, --help     Show CLI help.
  -v, --verbose

DESCRIPTION
  Installs a plugin into the CLI.
  Can be installed from npm or a git url.

  Installation of a user-installed plugin will override a core plugin.

  e.g. If you have a core plugin that has a 'hello' command, installing a
  user-installed plugin with a 'hello' command will override the core plugin
  implementation. This is useful if a user needs to update core plugin
  functionality in the CLI without the need to patch and update the whole CLI.


ALIASES
  $ heroku plugins:add

EXAMPLES
  $ heroku plugins:install myplugin

  $ heroku plugins:install https://github.com/someuser/someplugin

  $ heroku plugins:install someuser/someplugin

See code: @oclif/plugin-plugins

heroku plugins:link PLUGIN

Links a plugin into the CLI for development.

USAGE
  $ heroku plugins:link PLUGIN

ARGUMENTS
  PATH  [default: .] path to plugin

FLAGS
  -h, --help     Show CLI help.
  -v, --verbose

DESCRIPTION
  Links a plugin into the CLI for development.
  Installation of a linked plugin will override a user-installed or core plugin.

  e.g. If you have a user-installed or core plugin that has a 'hello' command,
  installing a linked plugin with a 'hello' command will override the
  user-installed or core plugin implementation. This is useful for development
  work.


EXAMPLES
  $ heroku plugins:link myplugin

See code: @oclif/plugin-plugins

heroku plugins:uninstall PLUGIN...

Removes a plugin from the CLI.

USAGE
  $ heroku plugins:uninstall PLUGIN...

ARGUMENTS
  PLUGIN  plugin to uninstall

FLAGS
  -h, --help     Show CLI help.
  -v, --verbose

DESCRIPTION
  Removes a plugin from the CLI.

ALIASES
  $ heroku plugins:unlink
  $ heroku plugins:remove

See code: @oclif/plugin-plugins

heroku plugins:update

Update installed plugins.

USAGE
  $ heroku plugins:update [-h] [-v]

FLAGS
  -h, --help     Show CLI help.
  -v, --verbose

DESCRIPTION
  Update installed plugins.

See code: @oclif/plugin-plugins

heroku ps [TYPE [TYPE ...]]

list dynos for an app

USAGE
  $ heroku ps [TYPE [TYPE ...]]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
      --json            display as json

DESCRIPTION
  list dynos for an app

EXAMPLES
  $ heroku ps
  === run: one-off dyno
  run.1: up for 5m: bash
  === web: bundle exec thin start -p $PORT
  web.1: created for 30s

  $ heroku ps run # specifying types
  === run: one-off dyno
  run.1: up for 5m: bash

See code: src/commands/ps/index.ts

heroku ps:autoscale:disable

disable web dyno autoscaling

USAGE
  $ heroku ps:autoscale:disable -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  disable web dyno autoscaling

See code: src/commands/ps/autoscale/disable.ts

heroku ps:autoscale:enable

enable web dyno autoscaling

USAGE
  $ heroku ps:autoscale:enable -a <value> --min <value> --max <value> [-r
    <value>] [--p95 <value>] [--notifications]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
      --max=<value>     (required) maximum number of dynos
      --min=<value>     (required) minimum number of dynos
      --notifications   receive email notifications when the max dyno limit is
                        reached
      --p95=<value>     desired p95 response time

DESCRIPTION
  enable web dyno autoscaling

See code: src/commands/ps/autoscale/enable.ts

heroku ps:copy FILE

Copy a file from a dyno to the local filesystem

USAGE
  $ heroku ps:copy FILE -a <value> [-d <value>] [-o <value>] [-r
    <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -d, --dyno=<value>    specify the dyno to connect to
  -o, --output=<value>  the name of the output file
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  Copy a file from a dyno to the local filesystem
  Example:

  $ heroku ps:copy FILENAME --app murmuring-headland-14719

heroku ps:exec

Create an SSH session to a dyno

USAGE
  $ heroku ps:exec -a <value> [-d <value>] [--ssh] [--status] [-r
    <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -d, --dyno=<value>    specify the dyno to connect to
  -r, --remote=<value>  git remote of app to use
      --ssh             use native ssh
      --status          lists the status of the SSH server in the dyno

DESCRIPTION
  Create an SSH session to a dyno
  Example:

  $ heroku ps:exec 'node -i' --app murmuring-headland-14719

heroku ps:forward PORT

Forward traffic on a local port to a dyno

USAGE
  $ heroku ps:forward PORT -a <value> [-d <value>] [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -d, --dyno=<value>    specify the dyno to connect to
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  Forward traffic on a local port to a dyno
  Provide a port or comma-separated list of ports to forward.

  For example, "4000,9000:9001" will forward port 4000 to port 4000 and
  port 9000 to port 9001.

  Example:

  $ heroku ps:forward 8080 --app murmuring-headland-14719

heroku ps:restart [DYNO]

restart an app dyno or process type

USAGE
  $ heroku ps:restart [DYNO] -a <value> [-r <value>] [-p <value> | -d
    <value>]

ARGUMENTS
  DYNO  name of the dyno to restart

FLAGS
  -a, --app=<value>           (required) app to run command against
  -d, --dyno-name=<value>     name of the dyno to restart
  -p, --process-type=<value>  name of the process type to restart
  -r, --remote=<value>        git remote of app to use

DESCRIPTION
  restart an app dyno or process type
  if neither --dyno nor --type are specified, restarts all dynos on app


ALIASES
  $ heroku dyno:restart

EXAMPLES
  $ heroku ps:restart --app myapp --dyno-name web.1

  $ heroku ps:restart --app myapp --process-type web

  $ heroku ps:restart --app myapp

See code: src/commands/ps/restart.ts

heroku ps:scale

scale dyno quantity up or down

USAGE
  $ heroku ps:scale -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  scale dyno quantity up or down
  Appending a size (eg. web=2:Standard-2X) allows simultaneous scaling and
  resizing.

  Omitting any arguments will display the app's current dyno formation, in a
  format suitable for passing back into ps:scale.


ALIASES
  $ heroku dyno:scale

EXAMPLES
  $ heroku ps:scale web=3:Standard-2X worker+1 --app APP
  Scaling dynos... done, now running web at 3:Standard-2X, worker at 1:Standard-1X.

  $ heroku ps:scale --app APP
  web=3:Standard-2X worker=1:Standard-1X

See code: src/commands/ps/scale.ts

heroku ps:socks

Launch a SOCKS proxy into a dyno

USAGE
  $ heroku ps:socks -a <value> [-d <value>] [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -d, --dyno=<value>    specify the dyno to connect to
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  Launch a SOCKS proxy into a dyno
  Example:

  $ heroku ps:socks --app murmuring-headland-14719
  Establishing credentials... done
  SOCKSv5 proxy server started on port 1080
  Use CTRL+C to stop the proxy

heroku ps:stop [DYNO]

stop an app dyno or process type

USAGE
  $ heroku ps:stop [DYNO] -a <value> [-r <value>] [-p <value> | -d
    <value>]

ARGUMENTS
  DYNO  name of the dyno to stop

FLAGS
  -a, --app=<value>           (required) app to run command against
  -d, --dyno-name=<value>     name of the dyno to stop
  -p, --process-type=<value>  name of the process type to stop
  -r, --remote=<value>        git remote of app to use

DESCRIPTION
  stop an app dyno or process type

ALIASES
  $ heroku dyno:stop
  $ heroku ps:kill
  $ heroku dyno:kill

EXAMPLES
  $ heroku ps:stop --app myapp --dyno-name run.1828

  $ heroku ps:stop --app myapp --process-type run

See code: src/commands/ps/stop.ts

heroku ps:type

manage dyno sizes

USAGE
  $ heroku ps:type -a <value> [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  manage dyno sizes
  Called with no arguments shows the current dyno size.

  Called with one argument sets the size.
  Where SIZE is one of eco|basic|standard-1x|standard-2x|performance

  Called with 1..n TYPE=SIZE arguments sets the quantity per type.


ALIASES
  $ heroku ps:resize
  $ heroku dyno:resize

See code: src/commands/ps/type.ts

heroku ps:wait

wait for all dynos to be running latest version after a release

USAGE
  $ heroku ps:wait -a <value> [-r <value>] [-w <value>] [-R | -t
    <value>]

FLAGS
  -R, --with-run               whether to wait for one-off run dynos
  -a, --app=<value>            (required) app to run command against
  -r, --remote=<value>         git remote of app to use
  -t, --type=<value>           wait for one specific dyno type
  -w, --wait-interval=<value>  [default: 10] how frequently to poll in seconds
                               (to avoid hitting Heroku API rate limits)

DESCRIPTION
  wait for all dynos to be running latest version after a release

See code: src/commands/ps/wait.ts

heroku redis:cli [DATABASE]

opens a redis prompt

USAGE
  $ heroku redis:cli [DATABASE] -a <value> [-c <value>] [-r <value>]

ARGUMENTS
  DATABASE  name of the Key-Value Store database. If omitted, it defaults to the
            primary database associated with the app.

FLAGS
  -a, --app=<value>      (required) app to run command against
  -c, --confirm=<value>
  -r, --remote=<value>   git remote of app to use

DESCRIPTION
  opens a redis prompt

EXAMPLES
  $ heroku redis:cli --app=my-app my-database

  $ heroku redis:cli --app=my-app --confirm my-database

See code: src/commands/redis/cli.ts

heroku redis:credentials [DATABASE]

display credentials information

USAGE
  $ heroku redis:credentials [DATABASE] -a <value> [-r <value>] [--reset]

ARGUMENTS
  DATABASE  name of the Key-Value Store database. If omitted, it defaults to the
            primary database associated with the app.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
      --reset           reset credentials

DESCRIPTION
  display credentials information

See code: src/commands/redis/credentials.ts

heroku redis:info [DATABASE]

gets information about redis

USAGE
  $ heroku redis:info [DATABASE] -a <value> [-r <value>] [-j]

ARGUMENTS
  DATABASE  name of the Key-Value Store database. If omitted, it defaults to the
            primary database associated with the app.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -j, --json            output in json format
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  gets information about redis

ALIASES
  $ heroku redis

See code: src/commands/redis/info.ts

heroku redis:keyspace-notifications [DATABASE]

set the keyspace notifications configuration

USAGE
  $ heroku redis:keyspace-notifications [DATABASE] -a <value> -c <value> [-r
  <value>]

ARGUMENTS
  DATABASE  name of the Key-Value Store database. If omitted, it defaults to the
            primary database associated with the app.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -c, --config=<value>  (required) set keyspace notifications configuration
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  set the keyspace notifications configuration
  Set the configuration to enable keyspace notification events:
  K     Keyspace events, published with __keyspace@<db>__ prefix.
  E     Keyevent events, published with __keyevent@<db>__ prefix.
  g     Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ...
  $     String commands
  l     List commands
  s     Set commands
  h     Hash commands
  z     Sorted set commands
  t     Stream commands
  x     Expired events (events generated every time a key expires)
  e     Evicted events (events generated when a key is evicted for maxmemory)
  m     Key miss events (events generated when a key that doesn't exist is
  accessed)
  A     Alias for "g$lshztxe", so that the "AKE" string means all the events
  except "m".

  pass an empty string ('') to disable keyspace notifications

See code: src/commands/redis/keyspace-notifications.ts

heroku redis:maintenance [DATABASE]

manage maintenance windows

USAGE
  $ heroku redis:maintenance [DATABASE] -a <value> [-r <value>] [-w <value>]
    [--run] [-f]

ARGUMENTS
  DATABASE  name of the Key-Value Store database. If omitted, it defaults to the
            primary database associated with the app.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -f, --force           start maintenance without entering application
                        maintenance mode
  -r, --remote=<value>  git remote of app to use
  -w, --window=<value>  set weekly UTC maintenance window (format: "Day HH:MM",
                        where MM is 00 or 30)
      --run             start maintenance

DESCRIPTION
  manage maintenance windows
  Set or change the maintenance window for your Redis instance

See code: src/commands/redis/maintenance.ts

heroku redis:maxmemory [DATABASE]

set the key eviction policy when instances reach their storage limit

USAGE
  $ heroku redis:maxmemory [DATABASE] -a <value> -p <value> [-r <value>]

ARGUMENTS
  DATABASE  name of the Key-Value Store database. If omitted, it defaults to the
            primary database associated with the app.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -p, --policy=<value>  (required) set policy name
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  set the key eviction policy when instances reach their storage limit
  Available policies for key eviction include:

  noeviction      # returns errors when memory limit is reached
  allkeys-lfu     # removes less frequently used keys first
  volatile-lfu    # removes less frequently used keys first that have an expiry
  set
  allkeys-lru     # removes less recently used keys first
  volatile-lru    # removes less recently used keys first that have an expiry
  set
  allkeys-random  # evicts random keys
  volatile-random # evicts random keys but only those that have an expiry set
  volatile-ttl    # only evicts keys with an expiry set and a short TTL

See code: src/commands/redis/maxmemory.ts

heroku redis:promote [DATABASE]

sets DATABASE as your REDIS_URL

USAGE
  $ heroku redis:promote [DATABASE] -a <value> [-r <value>]

ARGUMENTS
  DATABASE  name of the Key-Value Store database. If omitted, it defaults to the
            primary database associated with the app.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  sets DATABASE as your REDIS_URL

See code: src/commands/redis/promote.ts

heroku redis:stats-reset [DATABASE]

reset all stats covered by RESETSTAT (https://redis.io/commands/config-resetstat)

USAGE
  $ heroku redis:stats-reset [DATABASE] -a <value> [-r <value>] [-c <value>]

ARGUMENTS
  DATABASE  name of the Key-Value Store database. If omitted, it defaults to the
            primary database associated with the app.

FLAGS
  -a, --app=<value>      (required) app to run command against
  -c, --confirm=<value>
  -r, --remote=<value>   git remote of app to use

DESCRIPTION
  reset all stats covered by RESETSTAT
  (https://redis.io/commands/config-resetstat)

See code: src/commands/redis/stats-reset.ts

heroku redis:timeout [DATABASE]

set the number of seconds to wait before killing idle connections

USAGE
  $ heroku redis:timeout [DATABASE] -a <value> -s <value> [-r <value>]

ARGUMENTS
  DATABASE  name of the Key-Value Store database. If omitted, it defaults to the
            primary database associated with the app.

FLAGS
  -a, --app=<value>      (required) app to run command against
  -r, --remote=<value>   git remote of app to use
  -s, --seconds=<value>  (required) set timeout value

DESCRIPTION
  set the number of seconds to wait before killing idle connections
  A value of zero means that connections will not be closed.

See code: src/commands/redis/timeout.ts

heroku redis:upgrade [DATABASE]

perform in-place version upgrade

USAGE
  $ heroku redis:upgrade [DATABASE] -a <value> -v <value> [-r <value>] [-c
    <value>]

ARGUMENTS
  DATABASE  name of the Key-Value Store database. If omitted, it defaults to the
            primary database associated with the app.

FLAGS
  -a, --app=<value>      (required) app to run command against
  -c, --confirm=<value>
  -r, --remote=<value>   git remote of app to use
  -v, --version=<value>  (required)

DESCRIPTION
  perform in-place version upgrade

See code: src/commands/redis/upgrade.ts

heroku redis:wait [DATABASE]

wait for Redis instance to be available

USAGE
  $ heroku redis:wait [DATABASE] -a <value> [--wait-interval <value>]
    [-r <value>]

ARGUMENTS
  DATABASE  name of the Key-Value Store database. If omitted, it defaults to the
            primary database associated with the app.

FLAGS
  -a, --app=<value>            (required) app to run command against
  -r, --remote=<value>         git remote of app to use
      --wait-interval=<value>  how frequently to poll in seconds

DESCRIPTION
  wait for Redis instance to be available

See code: src/commands/redis/wait.ts

heroku regions

list available regions for deployment

USAGE
  $ heroku regions [--json] [--private] [--common]

FLAGS
  --common   show regions for common runtime
  --json     output in json format
  --private  show regions for private spaces

DESCRIPTION
  list available regions for deployment

See code: src/commands/regions.ts

heroku releases

display the releases for an app

USAGE
  $ heroku releases -a <value> [-n <value>] [--json] [-r <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -n, --num=<value>     number of releases to show
  -r, --remote=<value>  git remote of app to use
      --json            output releases in json format

DESCRIPTION
  display the releases for an app

EXAMPLES
  v1 Config add FOO_BAR email@example.com 2015/11/17 17:37:41 (~ 1h ago)

  v2 Config add BAR_BAZ email@example.com 2015/11/17 17:37:41 (~ 1h ago)

  v3 Config add BAZ_QUX email@example.com 2015/11/17 17:37:41 (~ 1h ago)

See code: src/commands/releases/index.ts

heroku releases:info [RELEASE]

view detailed information for a release

USAGE
  $ heroku releases:info [RELEASE] -a <value> [--json] [-s] [-r <value>]

ARGUMENTS
  RELEASE  ID of the release. If omitted, we use the last release ID.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
  -s, --shell           output in shell format
      --json            output in json format

DESCRIPTION
  view detailed information for a release

See code: src/commands/releases/info.ts

heroku releases:output [RELEASE]

View the release command output

USAGE
  $ heroku releases:output [RELEASE] -a <value> [-r <value>]

ARGUMENTS
  RELEASE  ID of the release. If omitted, we use the last release ID.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  View the release command output

See code: src/commands/releases/output.ts

heroku releases:retry

retry the latest release-phase command

USAGE
  $ heroku releases:retry -a <value>

FLAGS
  -a, --app=<value>  (required) app to run command against

DESCRIPTION
  retry the latest release-phase command

EXAMPLES
  $ heroku releases:retry --app happy-samurai-42

See code: src/commands/releases/retry.ts

heroku releases:rollback [RELEASE]

Roll back to a previous release.

USAGE
  $ heroku releases:rollback [RELEASE] -a <value> [-r <value>]

ARGUMENTS
  RELEASE  ID of the release. If omitted, we use the last eligible release.

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  Roll back to a previous release.

  If RELEASE is not specified, it will roll back to the last eligible release.

See code: src/commands/releases/rollback.ts

heroku reviewapps:disable

disable review apps and/or settings on an existing pipeline

USAGE
  $ heroku reviewapps:disable -p <value> [-a <value>] [-r <value>]
    [--no-autodeploy] [--no-autodestroy] [--no-wait-for-ci]

FLAGS
  -a, --app=<value>       parent app used by review apps
  -p, --pipeline=<value>  (required) name of pipeline
  -r, --remote=<value>    git remote of app to use
      --no-autodeploy     disable autodeployments
      --no-autodestroy    disable automatically destroying review apps
      --no-wait-for-ci    disable wait for CI

DESCRIPTION
  disable review apps and/or settings on an existing pipeline

EXAMPLES
  $ heroku reviewapps:disable -p my-pipeline -a my-app --no-autodeploy

See code: src/commands/reviewapps/disable.ts

heroku reviewapps:enable

enable review apps and/or settings on an existing pipeline

USAGE
  $ heroku reviewapps:enable -p <value> [-a <value>] [-r <value>]
    [--autodeploy] [--autodestroy] [--wait-for-ci]

FLAGS
  -a, --app=<value>       parent app used by review apps
  -p, --pipeline=<value>  (required) name of pipeline
  -r, --remote=<value>    git remote of app to use
      --autodeploy        autodeploy the review app
      --autodestroy       autodestroy the review app
      --wait-for-ci       wait for CI to pass before deploying

DESCRIPTION
  enable review apps and/or settings on an existing pipeline

EXAMPLES
  $ heroku reviewapps:enable -p my-pipeline -a my-app --autodeploy --autodestroy

See code: src/commands/reviewapps/enable.ts

heroku run

run a one-off process inside a heroku dyno

USAGE
  $ heroku run -a <value> [-r <value>] [-s <value>] [--type
    <value>] [-x] [-e <value>] [--no-tty] [--no-notify]

FLAGS
  -a, --app=<value>     (required) parent app used by review apps
  -e, --env=<value>     environment variables to set (use ';' to split multiple
                        vars)
  -r, --remote=<value>  git remote of app to use
  -s, --size=<value>    dyno size
  -x, --exit-code       passthrough the exit code of the remote command
      --no-notify       disables notification when dyno is up (alternatively use
                        HEROKU_NOTIFICATIONS=0)
      --no-tty          force the command to not run in a tty
      --type=<value>    process type

DESCRIPTION
  run a one-off process inside a heroku dyno
  Shows a notification if the dyno takes more than 20 seconds to start.

EXAMPLES
  $ heroku run bash

  $ heroku run -s standard-2x -- myscript.sh -a arg1 -s arg2

See code: src/commands/run/index.ts

heroku run:detached

run a detached dyno, where output is sent to your logs

USAGE
  $ heroku run:detached -a <value> [-r <value>] [-e <value>] [-s <value>]
    [-t] [--type <value>]

FLAGS
  -a, --app=<value>     (required) app to run command against
  -e, --env=<value>     environment variables to set (use ';' to split multiple
                        vars)
  -r, --remote=<value>  git remote of app to use
  -s, --size=<value>    dyno size
  -t, --tail            continually stream logs
      --type=<value>    process type

DESCRIPTION
  run a detached dyno, where output is sent to your logs

EXAMPLES
  $ heroku run:detached ls

See code: src/commands/run/detached.ts

heroku run:inside DYNO_NAME COMMAND

run a command inside an existing dyno (for Fir-generation apps only)

USAGE
  $ heroku run:inside DYNO_NAME... COMMAND... -a <value> [-x]
    [--no-launcher] [-r <value>]

ARGUMENTS
  DYNO_NAME...  name of the dyno to run command inside
  COMMAND...    command to run (Heroku automatically prepends ‘launcher’ to the
                command)

FLAGS
  -a, --app=<value>     (required) app to run command against
  -r, --remote=<value>  git remote of app to use
  -x, --exit-code       passthrough the exit code of the remote command
      --no-launcher     don’t prepend ‘launcher’ before a command

DESCRIPTION
  run a command inside an existing dyno (for Fir-generation apps only)

EXAMPLES
  Run bash

    $ heroku run:inside web-848cd4f64d-pvpr2 bash -a my-app

  Run a command supplied by a script taking option flags

    $ heroku run:inside web-848cd4f64d-pvpr2 -a my-app -- myscript.sh -x \
      --log-level=warn

  Run a command declared for the worker process type in a Procfile

    $ heroku run:inside web-848cd4f64d-pvpr2 worker -a my-app

See code: src/commands/run/inside.ts

heroku sessions

list your OAuth sessions

USAGE
  $ heroku sessions [-j]

FLAGS
  -j, --json  output in json format

DESCRIPTION
  list your OAuth sessions

See code: src/commands/sessions/index.ts

heroku sessions:destroy ID

delete (logout) OAuth session by ID

USAGE
  $ heroku sessions:destroy ID

ARGUMENTS
  ID  ID of the OAuth session

DESCRIPTION
  delete (logout) OAuth session by ID

See code: src/commands/sessions/destroy.ts

heroku spaces

list available spaces

USAGE
  $ heroku spaces [--json] [-t <value>]

FLAGS
  -t, --team=<value>  team to use
      --json          output in json format

DESCRIPTION
  list available spaces

See code: src/commands/spaces/index.ts

heroku spaces:create

create a new space

USAGE
  $ heroku spaces:create [SPACE] -t <value> [--cidr <value>] [--data-cidr
    <value>] [--generation cedar|fir] [--region <value>] [-s <value>]

FLAGS
  -s, --space=<value>        name of space to create
  -t, --team=<value>         (required) team to use
      --cidr=<value>         RFC-1918 CIDR the space will use
      --data-cidr=<value>    RFC-1918 CIDR used by Heroku Data resources for the
                             space
      --generation=<option>  [default: cedar] generation for space
                             <options: cedar|fir>
      --region=<value>       region name

DESCRIPTION
  create a new space


EXAMPLES
  Example:
  $ heroku spaces:create --space my-space --team my-team --region oregon
  Creating space my-space in team my-team... done
  === my-space
  ID:         e7b99e37-69b3-4475-ad47-a5cc5d75fd9f
  Team:       my-team
  Region:     oregon
  CIDR:       10.0.0.0/16
  Data CIDR:  172.23.0.0/20
  State:      allocating
  Generation: cedar
  Created at: 2016-01-06T03:23:13Z

See code: src/commands/spaces/create.ts

heroku spaces:destroy

destroy a space

USAGE
  $ heroku spaces:destroy [SPACE] [-s <value>] [--confirm <value>]

FLAGS
  -s, --space=<value>    space to destroy
      --confirm=<value>  set to space name to bypass confirm prompt

DESCRIPTION
  destroy a space


EXAMPLES
  $ heroku spaces:destroy --space my-space
  Destroying my-space... done

See code: src/commands/spaces/destroy.ts

heroku spaces:info

show info about a space

USAGE
  $ heroku spaces:info [SPACE] [-s <value>] [--json]

FLAGS
  -s, --space=<value>  space to get info of
      --json           output in json format

DESCRIPTION
  show info about a space

EXAMPLES
  $ heroku spaces:info my-space

See code: src/commands/spaces/info.ts

heroku spaces:peerings

list peering connections for a space

USAGE
  $ heroku spaces:peerings [SPACE] [-s <value>] [--json]

FLAGS
  -s, --space=<value>  space to get peer list from
      --json           output in json format

DESCRIPTION
  list peering connections for a space

See code: src/commands/spaces/peerings/index.ts

heroku spaces:peerings:accept

accepts a pending peering request for a private space

USAGE
  $ heroku spaces:peerings:accept [PCXID] [SPACE] [-p <value>] [-s <value>]

FLAGS
  -p, --pcxid=<value>  PCX ID of a pending peering
  -s, --space=<value>  space to get peering info from

DESCRIPTION
  accepts a pending peering request for a private space

EXAMPLES
  $ heroku spaces:peerings:accept pcx-4bd27022 --space example-space
      Accepting and configuring peering connection pcx-4bd27022

See code: src/commands/spaces/peerings/accept.ts

heroku spaces:peerings:destroy

destroys an active peering connection in a private space

USAGE
  $ heroku spaces:peerings:destroy [PCXID] -s <value> [-p <value>] [--confirm
  <value>]

FLAGS
  -p, --pcxid=<value>    PCX ID of a pending peering
  -s, --space=<value>    (required) space to get peering info from
      --confirm=<value>  set to PCX ID to bypass confirm prompt

DESCRIPTION
  destroys an active peering connection in a private space

EXAMPLES
  $ heroku spaces:peerings:destroy pcx-4bd27022 --confirm pcx-4bd27022 --space example-space
  Tearing down peering connection pcx-4bd27022... done

See code: src/commands/spaces/peerings/destroy.ts

heroku spaces:peerings:info

display the information necessary to initiate a peering connection

USAGE
  $ heroku spaces:peerings:info [SPACE] [-s <value>] [--json]

FLAGS
  -s, --space=<value>  space to get peering info from
      --json           output in json format

DESCRIPTION
  display the information necessary to initiate a peering connection

  You will use the information provided by this command to establish a peering
  connection request from your AWS VPC to your private space.

  To start the peering process, go into your AWS console for the VPC you would
  like peered with your Private Space,
  navigate to the VPC service, choose the "Peering Connections" option and click
  the "Create peering connection" button.

  - The AWS Account ID and VPC ID are necessary for the AWS VPC Peering
  connection wizard.
  - You will also need to configure your VPC route table to route the Dyno CIDRs
  through the peering connection.

  Once you've established the peering connection request, you can use the
  spaces:peerings:accept command to accept and
  configure the peering connection for the space.


EXAMPLES
  $ heroku spaces:peering:info example-space
  === example-space  Peering Info
  AWS Account ID:    012345678910
  AWS Region:        us-west-2
  AWS VPC ID:        vpc-baadf00d
  AWS VPC CIDR:      10.0.0.0/16
  Space CIDRs:       10.0.128.0/20, 10.0.144.0/20
  Unavailable CIDRs: 10.1.0.0/16

See code: src/commands/spaces/peerings/info.ts

heroku spaces:ps

list dynos for a space

USAGE
  $ heroku spaces:ps [SPACE] [-s <value>] [--json]

FLAGS
  -s, --space=<value>  space to get dynos of
      --json           output in json format

DESCRIPTION
  list dynos for a space

See code: src/commands/spaces/ps.ts

heroku spaces:rename

renames a space

USAGE
  $ heroku spaces:rename --from <value> --to <value>

FLAGS
  --from=<value>  (required) current name of space
  --to=<value>    (required) desired name of space

DESCRIPTION
  renames a space

EXAMPLES
  $ heroku spaces:rename --from old-space-name --to new-space-name
  Renaming space old-space-name to new-space-name... done

See code: src/commands/spaces/rename.ts

heroku spaces:topology

show space topology

USAGE
  $ heroku spaces:topology [SPACE] [-s <value>] [--json]

FLAGS
  -s, --space=<value>  space to get topology of
      --json           output in json format

DESCRIPTION
  show space topology

See code: src/commands/spaces/topology.ts

heroku spaces:transfer

transfer a space to another team

USAGE
  $ heroku spaces:transfer -s <value> -t <value>

FLAGS
  -s, --space=<value>  (required) name of space
  -t, --team=<value>   (required) desired owner of space

DESCRIPTION
  transfer a space to another team

EXAMPLES
  $ heroku spaces:transfer --space=space-name --team=team-name
  Transferring space-name to team-name... done

See code: src/commands/spaces/transfer.ts

heroku spaces:trusted-ips

list trusted IP ranges for a space

USAGE
  $ heroku spaces:trusted-ips [SPACE] [-s <value>] [--json]

FLAGS
  -s, --space=<value>  space to get inbound rules from
      --json           output in json format

DESCRIPTION
  list trusted IP ranges for a space
  Trusted IP ranges are only available on Private Spaces.

  The space name is a required parameter. Newly created spaces will have
  0.0.0.0/0 set by default
  allowing all traffic to applications in the space. More than one CIDR block
  can be provided at
  a time to the commands listed below. For example 1.2.3.4/20 and 5.6.7.8/20 can
  be added with:

See code: src/commands/spaces/trusted-ips/index.ts

heroku spaces:trusted-ips:add SOURCE

Add one range to the list of trusted IP ranges

USAGE
  $ heroku spaces:trusted-ips:add SOURCE -s <value> [--confirm <value>]

ARGUMENTS
  SOURCE  IP address in CIDR notation

FLAGS
  -s, --space=<value>    (required) space to add rule to
      --confirm=<value>  set to space name to bypass confirm prompt

DESCRIPTION
  Add one range to the list of trusted IP ranges
  Uses CIDR notation.

EXAMPLES
  $ heroku trusted-ips:add --space my-space 192.168.2.0/24
    Added 192.168.0.1/24 to trusted IP ranges on my-space

See code: src/commands/spaces/trusted-ips/add.ts

heroku spaces:trusted-ips:remove SOURCE

Remove a range from the list of trusted IP ranges

USAGE
  $ heroku spaces:trusted-ips:remove SOURCE -s <value> [--confirm <value>]

ARGUMENTS
  SOURCE  IP address in CIDR notation

FLAGS
  -s, --space=<value>    (required) space to remove rule from
      --confirm=<value>  set to space name to bypass confirm prompt

DESCRIPTION
  Remove a range from the list of trusted IP ranges
  Uses CIDR notation.

EXAMPLES
  $ heroku trusted-ips:remove --space my-space 192.168.2.0/24
      Removed 192.168.2.0/24 from trusted IP ranges on my-space

See code: src/commands/spaces/trusted-ips/remove.ts

heroku spaces:vpn:config NAME

display the configuration information for VPN

USAGE
  $ heroku spaces:vpn:config NAME -s <value> [--json]

ARGUMENTS
  NAME  name or id of the VPN connection to retrieve config from

FLAGS
  -s, --space=<value>  (required) space the VPN connection belongs to
      --json           output in json format

DESCRIPTION
  display the configuration information for VPN

  You will use the information provided by this command to establish a Private
  Space VPN Connection.

  - You must configure your VPN Gateway to use both Tunnels provided by Heroku
  - The VPN Gateway values are the IP addresses of the Private Space Tunnels
  - The Customer Gateway value is the Public IP of your VPN Gateway
  - The VPN Gateway must use the IKE Version shown and the Pre-shared Keys as
  the authentication method


EXAMPLES
  $ heroku spaces:vpn:config vpn-connection-name --space my-space
  === vpn-connection-name VPN Tunnels
   VPN Tunnel Customer Gateway VPN Gateway    Pre-shared Key Routable Subnets IKE Version
   ────────── ──────────────── ────────────── ────────────── ──────────────── ───────────
   Tunnel 1    104.196.121.200   35.171.237.136  abcdef12345     10.0.0.0/16       1
   Tunnel 2    104.196.121.200   52.44.7.216     fedcba54321     10.0.0.0/16       1

See code: src/commands/spaces/vpn/config.ts

heroku spaces:vpn:connect NAME

create VPN

USAGE
  $ heroku spaces:vpn:connect NAME -i <value> -c <value> -s <value>

ARGUMENTS
  NAME  name or id of the VPN connection to create

FLAGS
  -c, --cidrs=<value>  (required) a list of routable CIDRs separated by commas
  -i, --ip=<value>     (required) public IP of customer gateway
  -s, --space=<value>  (required) space name

DESCRIPTION
  create VPN
  Private Spaces can be connected to another private network via an IPSec VPN
  connection allowing dynos to connect to hosts on your private networks and
  vice versa.
  The connection is established over the public Internet but all traffic is
  encrypted using IPSec.


EXAMPLES
  $ heroku spaces:vpn:connect vpn-connection-name --ip 35.161.69.30 --cidrs 172.16.0.0/16,10.0.0.0/24 --space my-space
  Creating VPN Connection in space my-space... done
  ▸    Use spaces:vpn:wait to track allocation.

See code: src/commands/spaces/vpn/connect.ts

heroku spaces:vpn:connections

list the VPN Connections for a space

USAGE
  $ heroku spaces:vpn:connections -s <value> [--json]

FLAGS
  -s, --space=<value>  (required) space to get VPN connections from
      --json           output in json format

DESCRIPTION
  list the VPN Connections for a space

EXAMPLES
  $ heroku spaces:vpn:connections --space my-space
  === my-space VPN Connections
   Name   Status Tunnels
   ────── ────── ───────
   office active UP/UP

See code: src/commands/spaces/vpn/connections.ts

heroku spaces:vpn:destroy NAME

destroys VPN in a private space

USAGE
  $ heroku spaces:vpn:destroy NAME -s <value>

ARGUMENTS
  NAME  name or id of the VPN connection to destroy

FLAGS
  -s, --space=<value>  (required) space name

DESCRIPTION
  destroys VPN in a private space

EXAMPLES
  $ heroku spaces:vpn:destroy vpn-connection-name --space example-space --confirm vpn-connection-name
  Tearing down VPN Connection vpn-connection-name in space example-space

See code: src/commands/spaces/vpn/destroy.ts

heroku spaces:vpn:info NAME

display the information for VPN

USAGE
  $ heroku spaces:vpn:info NAME -s <value> [--json]

ARGUMENTS
  NAME  name or id of the VPN connection to get info from

FLAGS
  -s, --space=<value>  (required) space the vpn connection belongs to
      --json           output in json format

DESCRIPTION
  display the information for VPN

EXAMPLES
  $ heroku spaces:vpn:info vpn-connection-name --space my-space
  === vpn-connection-name VPN Tunnel Info
  Name:           vpn-connection-name
  ID:             123456789012
  Public IP:      35.161.69.30
  Routable CIDRs: 172.16.0.0/16
  Status:         failed
  Status Message: supplied CIDR block already in use
  === my-space Tunnel Info
   VPN Tunnel IP Address    Status Last Changed         Details
   ────────── ───────────── ────── ──────────────────── ─────────────
   Tunnel 1   52.44.146.197 UP     2016-10-25T22:09:05Z status message
   Tunnel 2   52.44.146.197 UP     2016-10-25T22:09:05Z status message

See code: src/commands/spaces/vpn/info.ts

heroku spaces:vpn:update NAME

update VPN

USAGE
  $ heroku spaces:vpn:update NAME -c <value> -s <value>

ARGUMENTS
  NAME  name or id of the VPN connection to update

FLAGS
  -c, --cidrs=<value>  (required) a list of routable CIDRs separated by commas
  -s, --space=<value>  (required) space name

DESCRIPTION
  update VPN
  Private Spaces can be connected to another private network via an IPSec VPN
  connection allowing dynos to connect to hosts on your private networks and
  vice versa.
  The connection is established over the public Internet but all traffic is
  encrypted using IPSec.


EXAMPLES
  $ heroku spaces:vpn:update vpn-connection-name --space my-space --cidrs 172.16.0.0/16,10.0.0.0/24
  Updating VPN Connection in space my-space... done

See code: src/commands/spaces/vpn/update.ts

heroku spaces:vpn:wait NAME

wait for VPN Connection to be created

USAGE
  $ heroku spaces:vpn:wait NAME -s <value> [--json] [-i <value>] [-t <value>]

ARGUMENTS
  NAME  name or id of the VPN connection you are waiting on for allocation.

FLAGS
  -i, --interval=<value>  seconds to wait between poll intervals
  -s, --space=<value>     (required) space the vpn connection belongs to
  -t, --timeout=<value>   maximum number of seconds to wait
      --json              output in json format

DESCRIPTION
  wait for VPN Connection to be created

EXAMPLES
   $ heroku spaces:vpn:wait vpn-connection-name --space my-space
   Waiting for VPN Connection vpn-connection-name to allocate... done
   === my-space VPN Tunnels
  VPN Tunnel Customer Gateway VPN Gateway    Pre-shared Key Routable Subnets IKE Version
  ────────── ──────────────── ────────────── ────────────── ──────────────── ───────────
  Tunnel 1    104.196.121.200   35.171.237.136  abcdef12345     10.0.0.0/16       1
  Tunnel 2    104.196.121.200   52.44.7.216     fedcba54321     10.0.0.0/16       1

See code: src/commands/spaces/vpn/wait.ts

heroku spaces:wait

wait for a space to be created

USAGE
  $ heroku spaces:wait [SPACE] [-s <value>] [--json] [-i <value>] [-t
    <value>]

FLAGS
  -i, --interval=<value>  [default: 30] seconds to wait between poll intervals
  -s, --space=<value>     space to get info of
  -t, --timeout=<value>   [default: 1500] maximum number of seconds to wait
      --json              output in json format

DESCRIPTION
  wait for a space to be created

See code: src/commands/spaces/wait.ts

heroku status

display current status of the Heroku platform

USAGE
  $ heroku status [--json]

FLAGS
  --json  output in json format

DESCRIPTION
  display current status of the Heroku platform

See code: src/commands/status.ts

heroku teams

list the teams that you are a member of

USAGE
  $ heroku teams [--json]

FLAGS
  --json  output in json format

DESCRIPTION
  list the teams that you are a member of

  Use heroku members:* to manage team members.

See code: src/commands/teams/index.ts

heroku telemetry

list telemetry drains

USAGE
  $ heroku telemetry [-s <value>] [-a <value>]

FLAGS
  -a, --app=<value>    filter by app name
  -s, --space=<value>  filter by space name

DESCRIPTION
  list telemetry drains

EXAMPLES
  $ heroku telemetry

See code: src/commands/telemetry/index.ts

heroku telemetry:add ENDPOINT

Add and configure a new telemetry drain. Defaults to collecting all telemetry unless otherwise specified.

USAGE
  $ heroku telemetry:add ENDPOINT [-a <value>] [--headers <value>] [-s
    <value>] [--signals <value>] [--transport http|grpc]

ARGUMENTS
  ENDPOINT  drain url

FLAGS
  -a, --app=<value>         app to add a drain to
  -s, --space=<value>       space to add a drain to
      --headers=<value>     custom headers to configure the drain in json format
      --signals=<value>     [default: all] comma-delimited list of signals to
                            collect (traces, metrics, logs). Use "all" to
                            collect all signals.
      --transport=<option>  [default: http] transport protocol for the drain
                            <options: http|grpc>

DESCRIPTION
  Add and configure a new telemetry drain. Defaults to collecting all telemetry
  unless otherwise specified.

EXAMPLES
  Add a telemetry drain to an app to collect logs and traces:

    $ heroku telemetry:add https://my-endpoint.com --app myapp --signals \
      logs,traces --headers '{"x-drain-example-team": "API_KEY", \
      "x-drain-example-dataset": "METRICS_DATASET"}'

See code: src/commands/telemetry/add.ts

heroku telemetry:info TELEMETRY_DRAIN_ID

show a telemetry drain’s info

USAGE
  $ heroku telemetry:info TELEMETRY_DRAIN_ID

ARGUMENTS
  TELEMETRY_DRAIN_ID  ID of the drain to show info for

DESCRIPTION
  show a telemetry drain's info

EXAMPLES
  $ heroku telemetry:info 022e2e2e-2e2e-2e2e-2e2e-2e2e2e2e2e2e

See code: src/commands/telemetry/info.ts

heroku telemetry:remove [TELEMETRY_DRAIN_ID]

remove a telemetry drain

USAGE
  $ heroku telemetry:remove [TELEMETRY_DRAIN_ID] [-a <value>] [-s <value>]

ARGUMENTS
  TELEMETRY_DRAIN_ID  ID of the drain to remove

FLAGS
  -a, --app=<value>    name of the app to remove all drains from
  -s, --space=<value>  name of the space to remove all drains from

DESCRIPTION
  remove a telemetry drain

See code: src/commands/telemetry/remove.ts

heroku telemetry:update TELEMETRY_DRAIN_ID

updates a telemetry drain with provided attributes (attributes not provided remain unchanged)

USAGE
  $ heroku telemetry:update TELEMETRY_DRAIN_ID [--endpoint <value>] [--headers
    <value>] [--signals <value>] [--transport http|grpc]

ARGUMENTS
  TELEMETRY_DRAIN_ID  ID of the drain to update

FLAGS
  --endpoint=<value>    drain url
  --headers=<value>     custom headers to configure the drain in json format
  --signals=<value>     comma-delimited list of signals to collect (traces,
                        metrics, logs). Use "all" to collect all signals.
  --transport=<option>  transport protocol for the drain
                        <options: http|grpc>

DESCRIPTION
  updates a telemetry drain with provided attributes (attributes not provided
  remain unchanged)

EXAMPLES
  $ heroku telemetry:update acde070d-8c4c-4f0d-9d8a-162843c10333 --signals logs,metrics --endpoint https://my-new-endpoint.com

See code: src/commands/telemetry/update.ts

heroku update [CHANNEL]

update the heroku CLI

USAGE
  $ heroku update [CHANNEL] [-a] [-v <value> | -i] [--force]

FLAGS
  -a, --available        Install a specific version.
  -i, --interactive      Interactively select version to install. This is
                         ignored if a channel is provided.
  -v, --version=<value>  Install a specific version.
      --force            Force a re-download of the requested version.

DESCRIPTION
  update the heroku CLI

EXAMPLES
  Update to the stable channel:

    $ heroku update stable

  Update to a specific version:

    $ heroku update --version 1.0.0

  Interactively select version:

    $ heroku update --interactive

  See available versions:

    $ heroku update --available

See code: @oclif/plugin-update

heroku usage:addons

list usage for metered add-ons attached to an app or apps within a team

USAGE
  $ heroku usage:addons [-a <value>] [-t <value>]

FLAGS
  -a, --app=<value>   app to list metered add-ons usage for
  -t, --team=<value>  team to list metered add-ons usage for

DESCRIPTION
  list usage for metered add-ons attached to an app or apps within a team

See code: src/commands/usage/addons.ts

heroku version

USAGE
  $ heroku version [--json] [--verbose]

FLAGS
  --verbose  Show additional information about the CLI.

GLOBAL FLAGS
  --json  Format output as json.

FLAG DESCRIPTIONS
  --verbose  Show additional information about the CLI.

    Additionally shows the architecture, node version, operating system, and
    versions of plugins that the CLI is using.

See code: @oclif/plugin-version

heroku webhooks

list webhooks on an app

USAGE
  $ heroku webhooks [-a <value>] [-r <value>]

FLAGS
  -a, --app=<value>     app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  list webhooks on an app

EXAMPLES
  $ heroku webhooks

See code: src/commands/webhooks/index.ts

heroku webhooks:add

add a webhook to an app

USAGE
  $ heroku webhooks:add -i <value> -l <value> -u <value> [-a <value>] [-r
    <value>] [-s <value>] [-t <value>]

FLAGS
  -a, --app=<value>            app to run command against
  -i, --include=<value>        (required) comma delimited event types your
                               server will receive
  -l, --level=<value>          (required) notify does not retry, sync will retry
                               until successful or timeout
  -r, --remote=<value>         git remote of app to use
  -s, --secret=<value>         value to sign delivery with in
                               Heroku-Webhook-Hmac-SHA256 header
  -t, --authorization=<value>  authorization header to send with webhooks
  -u, --url=<value>            (required) URL for receiver

DESCRIPTION
  add a webhook to an app

EXAMPLES
  $ heroku webhooks:add -i api:dyno -l notify -u https://example.com/hooks

See code: src/commands/webhooks/add.ts

heroku webhooks:deliveries

list webhook deliveries on an app

USAGE
  $ heroku webhooks:deliveries [-a <value>] [-r <value>] [-s <value>]

FLAGS
  -a, --app=<value>     app to run command against
  -r, --remote=<value>  git remote of app to use
  -s, --status=<value>  filter deliveries by status

DESCRIPTION
  list webhook deliveries on an app

EXAMPLES
  $ heroku webhooks:deliveries

See code: src/commands/webhooks/deliveries/index.ts

heroku webhooks:deliveries:info ID

info for a webhook event on an app

USAGE
  $ heroku webhooks:deliveries:info ID [-a <value>] [-r <value>]

ARGUMENTS
  ID  ID of the webhook event

FLAGS
  -a, --app=<value>     app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  info for a webhook event on an app

EXAMPLES
  $ heroku webhooks:deliveries:info 99999999-9999-9999-9999-999999999999

See code: src/commands/webhooks/deliveries/info.ts

heroku webhooks:events

list webhook events on an app

USAGE
  $ heroku webhooks:events [-a <value>] [-r <value>]

FLAGS
  -a, --app=<value>     app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  list webhook events on an app

EXAMPLES
  $ heroku webhooks:events

See code: src/commands/webhooks/events/index.ts

heroku webhooks:events:info ID

info for a webhook event on an app

USAGE
  $ heroku webhooks:events:info ID [-a <value>] [-r <value>]

ARGUMENTS
  ID  ID of the webhook event

FLAGS
  -a, --app=<value>     app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  info for a webhook event on an app

EXAMPLES
  $ heroku webhooks:events:info 99999999-9999-9999-9999-999999999999

See code: src/commands/webhooks/events/info.ts

heroku webhooks:info ID

info for a webhook on an app

USAGE
  $ heroku webhooks:info ID [-a <value>] [-r <value>]

ARGUMENTS
  ID  ID of the webhook

FLAGS
  -a, --app=<value>     app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  info for a webhook on an app

EXAMPLES
  $ heroku webhooks:info 99999999-9999-9999-9999-999999999999

See code: src/commands/webhooks/info.ts

heroku webhooks:remove ID

removes a webhook from an app

USAGE
  $ heroku webhooks:remove ID [-a <value>] [-r <value>]

ARGUMENTS
  ID  id of webhook to remove

FLAGS
  -a, --app=<value>     app to run command against
  -r, --remote=<value>  git remote of app to use

DESCRIPTION
  removes a webhook from an app

EXAMPLES
  $ heroku webhooks:remove 99999999-9999-9999-9999-999999999999

See code: src/commands/webhooks/remove.ts

heroku webhooks:update ID

updates a webhook in an app

USAGE
  $ heroku webhooks:update ID -i <value> -l <value> -u <value> [-a <value>]
    [-r <value>] [-s <value>] [-t <value>]

ARGUMENTS
  ID  ID of the webhook

FLAGS
  -a, --app=<value>            app to run command against
  -i, --include=<value>        (required) comma delimited event types your
                               server will receive
  -l, --level=<value>          (required) notify does not retry, sync will retry
                               until successful or timeout
  -r, --remote=<value>         git remote of app to use
  -s, --secret=<value>         value to sign delivery with in
                               Heroku-Webhook-Hmac-SHA256 header
  -t, --authorization=<value>  authorization header to send with webhooks
  -u, --url=<value>            (required) URL for receiver

DESCRIPTION
  updates a webhook in an app

EXAMPLES
  $ heroku webhooks:update 99999999-9999-9999-9999-999999999999 -i dyno -l notify -s 09928c40bf1b191b645174a19f7053d16a180da37332e719ef0998f4c0a2 -u https://example.com/hooks

See code: src/commands/webhooks/update.ts

heroku which

Show which plugin a command is in.

USAGE
  $ heroku which

DESCRIPTION
  Show which plugin a command is in.

EXAMPLES
  See which plugin the `help` command is in:

    $ heroku which help

See code: @oclif/plugin-which

Keep reading

Command Line

Categories

Heroku CLI Commands