Heroku CLI Commands
Last updated November 13, 2024
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
list who has access to an app
USAGE
$ heroku access -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 who has access to an app
See code: src/commands/access/index.ts
heroku access:add EMAIL
add new users to your app
USAGE
$ heroku access:add EMAIL -a <value> [-r <value>] [-p <value>]
ARGUMENTS
EMAIL email address of the team member
FLAGS
-a, --app=<value> (required) app to run command against
-p, --permissions=<value> list of permissions comma separated
-r, --remote=<value> git remote of app to use
DESCRIPTION
add new users to your app
EXAMPLES
$ heroku access:add user@email.com --app APP # add a collaborator to your app
$ heroku access:add user@email.com --app APP --permissions deploy,manage,operate # permissions must be comma separated
See code: src/commands/access/add.ts
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 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:docs ADDON
open an add-on’s Dev Center documentation in your browser
USAGE
$ heroku addons:docs ADDON [--show-url] [-a <value>] [-r <value>]
ARGUMENTS
ADDON unique identifier or globally unique name of the add-on
FLAGS
-a, --app=<value> app to run command against
-r, --remote=<value> git remote of app to use
--show-url show URL, do not open browser
DESCRIPTION
open an add-on's Dev Center documentation in your browser
See code: src/commands/addons/docs.ts
heroku addons:info ADDON
show detailed add-on resource and attachment information
USAGE
$ heroku addons:info ADDON
ARGUMENTS
ADDON unique identifier or globally unique name of the add-on
FLAGS
-a, --app=<value> app to run command against
-r, --remote=<value> git remote of app to use
DESCRIPTION
show detailed add-on resource and attachment information
See code: src/commands/addons/info.ts
heroku addons:open ADDON
open an add-on’s dashboard in your browser
USAGE
$ heroku addons:open ADDON [--show-url] [-a <value>] [-r <value>]
ARGUMENTS
ADDON unique identifier or globally unique name of the add-on
FLAGS
-a, --app=<value> app to run command against
-r, --remote=<value> git remote of app to use
--show-url show URL, do not open browser
DESCRIPTION
open an add-on's dashboard in your browser
See code: src/commands/addons/open.ts
heroku addons:plans SERVICE
list all available plans for an add-on service
USAGE
$ heroku addons:plans SERVICE [--json]
ARGUMENTS
SERVICE unique identifier or globally unique name of the add-on
FLAGS
--json output in json format
DESCRIPTION
list all available plans for an add-on service
See code: src/commands/addons/plans.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 addons:wait [ADDON]
show provisioning status of the add-ons on the app
USAGE
$ heroku addons:wait [ADDON] [--wait-interval <value>] [-a <value>] [-r
<value>]
ARGUMENTS
ADDON unique identifier or globally unique name of the add-on
FLAGS
-a, --app=<value> app to run command against
-r, --remote=<value> git remote of app to use
--wait-interval=<value> how frequently to poll in seconds
DESCRIPTION
show provisioning status of the add-ons on the app
See code: src/commands/addons/wait.ts
heroku apps
list your apps
USAGE
$ heroku apps [-A] [-j] [-s <value>] [-p] [-t <value>]
FLAGS
-A, --all include apps in all teams
-j, --json output in json format
-p, --personal list apps in personal account when a default team is set
-s, --space=<value> filter by space
-t, --team=<value> team to use
DESCRIPTION
list your apps
EXAMPLES
$ heroku apps
See code: src/commands/apps/index.ts
heroku apps:create [APP]
creates a new app
USAGE
$ heroku apps:create [APP] [--addons <value>] [-b <value>] [-n] [-r
<value>] [-s <value>] [--space <value>] [--region <value>] [--json] [-t
<value>]
ARGUMENTS
APP name of app to create
FLAGS
-b, --buildpack=<value> buildpack url to use for this app
-n, --no-remote do not create a git remote
-r, --remote=<value> [default: heroku] the git remote to create, default
"heroku"
-s, --stack=<value> the stack to create the app on
-t, --team=<value> team to use
--addons=<value> comma-delimited list of addons to install
--json output in json format
--region=<value> specify region for the app to run in
--space=<value> the private space to create the app in
DESCRIPTION
creates a new app
EXAMPLES
$ heroku apps:create
Creating app... done, stack is heroku-24
https://floating-dragon-42.heroku.com/ | https://git.heroku.com/floating-dragon-42.git
# or just
$ heroku create
# use a heroku.yml manifest file
$ heroku apps:create --manifest
# specify a buildpack
$ heroku apps:create --buildpack https://github.com/some/buildpack.git
# specify a name
$ heroku apps:create example
# create a staging app
$ heroku apps:create example-staging --remote staging
# create an app in the eu region
$ heroku apps:create --region eu
See code: src/commands/apps/create.ts
heroku apps:destroy
permanently destroy an app
USAGE
$ heroku apps:destroy [APP] [-a <value>] [-r <value>] [-c <value>]
FLAGS
-a, --app=<value> app to run command against
-c, --confirm=<value>
-r, --remote=<value> git remote of app to use
DESCRIPTION
permanently destroy an app
See code: src/commands/apps/destroy.ts
heroku apps:errors
view app errors
USAGE
$ heroku apps:errors -a <value> [-r <value>] [--json] [--hours <value>]
[--router] [--dyno]
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
--dyno show only dyno errors
--hours=<value> [default: 24] number of hours to look back (default 24)
--json output in json format
--router show only router errors
DESCRIPTION
view app errors
See code: src/commands/apps/errors.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:info
show detailed app information
USAGE
$ heroku apps:info [APP] [-a <value>] [-r <value>] [-s] [-j]
FLAGS
-a, --app=<value> app to run command against
-j, --json output in json format
-r, --remote=<value> git remote of app to use
-s, --shell output more shell friendly key/value pairs
DESCRIPTION
show detailed app information
EXAMPLES
$ heroku apps:info
$ heroku apps:info --shell
See code: src/commands/apps/info.ts
heroku apps:join
add yourself to a team app
USAGE
$ heroku apps:join -a <value> [-r <value>]
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
DESCRIPTION
add yourself to a team app
ALIASES
$ heroku join
See code: src/commands/apps/join.ts
heroku apps:leave
remove yourself from a team app
USAGE
$ heroku apps:leave -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 yourself from a team app
ALIASES
$ heroku leave
EXAMPLES
$ heroku apps:leave -a APP
See code: src/commands/apps/leave.ts
heroku apps:lock
prevent team members from joining an app
USAGE
$ heroku apps:lock -a <value> [-r <value>]
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
DESCRIPTION
prevent team members from joining an app
ALIASES
$ heroku lock
See code: src/commands/apps/lock.ts
heroku apps:open [PATH]
open the app in a web browser
USAGE
$ heroku apps:open [PATH] -a <value> [-r <value>]
ARGUMENTS
PATH base URL path of app
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
DESCRIPTION
open the app in a web browser
EXAMPLES
$ heroku open -a myapp
$ heroku open -a myapp /foo
See code: src/commands/apps/open.ts
heroku apps:rename NEWNAME
rename an app
USAGE
$ heroku apps:rename NEWNAME -a <value> [-r <value>]
ARGUMENTS
NEWNAME new unique name of the app
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
DESCRIPTION
rename an app
EXAMPLES
$ heroku apps:rename --app oldname newname
See code: src/commands/apps/rename.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 apps:unlock
unlock an app so any team member can join
USAGE
$ heroku apps:unlock -a <value> [-r <value>]
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
DESCRIPTION
unlock an app so any team member can join
ALIASES
$ heroku unlock
See code: src/commands/apps/unlock.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 auth:2fa:disable
disables 2fa on account
USAGE
$ heroku auth:2fa:disable
DESCRIPTION
disables 2fa on account
ALIASES
$ heroku twofactor:disable
$ heroku 2fa:disable
EXAMPLES
$ heroku auth:2fa:disable
See code: src/commands/auth/2fa/disable.ts
heroku auth:login
login with your Heroku credentials
USAGE
$ heroku auth:login [--browser <value>] [-i] [-e <value>]
FLAGS
-e, --expires-in=<value> duration of token in seconds (default 30 days)
-i, --interactive login with username/password
--browser=<value> browser to open SSO with (example: "firefox",
"safari")
DESCRIPTION
login with your Heroku credentials
ALIASES
$ heroku login
See code: src/commands/auth/login.ts
heroku auth:logout
clears local login credentials and invalidates API session
USAGE
$ heroku auth:logout
DESCRIPTION
clears local login credentials and invalidates API session
ALIASES
$ heroku logout
See code: src/commands/auth/logout.ts
heroku auth:token
outputs current CLI authentication token.
USAGE
$ heroku auth:token [-h]
FLAGS
-h, --help Show CLI help.
DESCRIPTION
outputs current CLI authentication token.
By default, the CLI auth token is only valid for 1 year. To generate a
long-lived token, use heroku authorizations:create
See code: src/commands/auth/token.ts
heroku auth:whoami
display the current logged in user
USAGE
$ heroku auth:whoami
DESCRIPTION
display the current logged in user
ALIASES
$ heroku whoami
See code: src/commands/auth/whoami.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
display the buildpacks for 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
display the buildpacks for 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
list SSL certificates for an app
USAGE
$ heroku certs -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 SSL certificates for an app
See code: src/commands/certs/index.ts
heroku certs:add CRT KEY
Add an SSL certificate to an app.
USAGE
$ heroku certs:add CRT KEY -a <value> [-r <value>]
ARGUMENTS
CRT absolute path of the certificate file on disk
KEY absolute path of the key file on disk
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
DESCRIPTION
Add an SSL certificate to an app.
Note: certificates with PEM encoding are also valid.
EXAMPLES
$ heroku certs:add example.com.crt example.com.key
If you require intermediate certificates, refer to this article on merging certificates to get a complete chain:
https://help.salesforce.com/s/articleView?id=000333504&type=1
See code: src/commands/certs/add.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 certs:info
show certificate information for an SSL certificate
USAGE
$ heroku certs:info -a <value> [--name <value>] [--endpoint <value>]
[--show-domains] [-r <value>]
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
--endpoint=<value> endpoint to check info on
--name=<value> name to check info on
--show-domains show associated domains
DESCRIPTION
show certificate information for an SSL certificate
See code: src/commands/certs/info.ts
heroku certs:remove
remove an SSL certificate from an app
USAGE
$ heroku certs:remove -a <value> [--name <value>] [--endpoint <value>]
[-r <value>]
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
--endpoint=<value> endpoint to remove
--name=<value> name to remove
DESCRIPTION
remove an SSL certificate from an app
See code: src/commands/certs/remove.ts
heroku certs:update CRT KEY
update an SSL certificate on an app
USAGE
$ heroku certs:update CRT KEY -a <value> [--name <value>] [--endpoint
<value>] [-r <value>]
ARGUMENTS
CRT absolute path of the certificate file on disk
KEY absolute path of the key file on disk
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
--endpoint=<value> endpoint to update
--name=<value> name to update
DESCRIPTION
update an SSL certificate on an app
Note: certificates with PEM encoding are also valid
EXAMPLES
$ heroku certs:update example.com.crt example.com.key
If you require intermediate certificates, refer to this article on merging certificates to get a complete chain:
https://help.salesforce.com/s/articleView?id=000333504&type=1
See code: src/commands/certs/update.ts
heroku ci
display the most recent CI runs for the given pipeline
USAGE
$ heroku ci [-a <value>] [-r <value>] [--watch] [-p <value>]
[--json]
FLAGS
-a, --app=<value> app to run command against
-p, --pipeline=<value> name of pipeline
-r, --remote=<value> git remote of app to use
--json output in json format
--watch keep running and watch for new and update tests
DESCRIPTION
display the most recent CI runs for the given pipeline
EXAMPLES
$ heroku ci --app murmuring-headland-14719
See code: src/commands/ci/index.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:debug
opens an interactive test debugging session with the contents of the current directory
USAGE
$ heroku ci:debug [-a <value>] [--no-cache] [--no-setup] [-p <value>]
FLAGS
-a, --app=<value> app to run command against
-p, --pipeline=<value> name of pipeline
--no-cache start test run with an empty cache
--no-setup start test dyno without running test-setup
DESCRIPTION
opens an interactive test debugging session with the contents of the current
directory
See code: src/commands/ci/debug.ts
heroku ci:info TEST-RUN
show the status of a specific test run
USAGE
$ heroku ci:info TEST-RUN [-a <value>] [-r <value>] [--node
<value>] [-p <value>]
ARGUMENTS
TEST-RUN auto-incremented test run number
FLAGS
-a, --app=<value> app to run command against
-p, --pipeline=<value> name of pipeline
-r, --remote=<value> git remote of app to use
--node=<value> the node number to show its setup and output
DESCRIPTION
show the status of a specific test run
EXAMPLES
$ heroku ci:info 1288 --app murmuring-headland-14719
See code: src/commands/ci/info.ts
heroku ci:last
looks for the most recent run and returns the output of that run
USAGE
$ heroku ci:last [-a <value>] [-r <value>] [--node <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
--node=<value> the node number to show its setup and output
DESCRIPTION
looks for the most recent run and returns the output of that run
EXAMPLES
$ heroku ci:last --pipeline=my-pipeline --node 100
See code: src/commands/ci/last.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 ci:open
open the Dashboard version of Heroku CI
USAGE
$ heroku ci:open -a <value> [-h] [-r <value>] [-p <value>]
FLAGS
-a, --app=<value> (required) 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
DESCRIPTION
open the Dashboard version of Heroku CI
EXAMPLES
$ heroku ci:open --app murmuring-headland-14719
See code: src/commands/ci/open.ts
heroku ci:rerun [NUMBER]
rerun tests against current directory
USAGE
$ heroku ci:rerun [NUMBER] [-a <value>] [-r <value>] [-p <value>]
ARGUMENTS
NUMBER auto-incremented test run number
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
rerun tests against current directory
EXAMPLES
$ heroku ci:rerun 985 --app murmuring-headland-14719
See code: src/commands/ci/rerun.ts
heroku ci:run
run tests against current directory
USAGE
$ heroku ci:run [-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
run tests against current directory
EXAMPLES
$ heroku ci:run --app murmuring-headland-14719
See code: src/commands/ci/run.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:info ID
show details of an oauth client
USAGE
$ heroku clients:info ID [-j] [-s]
ARGUMENTS
ID ID of the OAuth client
FLAGS
-j, --json output in json format
-s, --shell output in shell format
DESCRIPTION
show details of an oauth client
EXAMPLES
$ heroku clients:info 36120128-fee7-455e-8b7f-807aee130946
See code: src/commands/clients/info.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 commands
list all the commands
USAGE
$ heroku commands [--json] [-h] [--hidden] [--tree] [--columns
<value> | -x] [--sort <value>] [--filter <value>] [--output csv|json|yaml |
| [--csv | --no-truncate]] [--no-header | ]
FLAGS
-h, --help Show CLI help.
-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
--hidden show hidden commands
--no-header hide table header from output
--no-truncate do not truncate output to fit screen
--output=<option> output in a more machine friendly format
<options: csv|json|yaml>
--sort=<value> property to sort by (prepend '-' for descending)
--tree show tree of commands
GLOBAL FLAGS
--json Format output as json.
DESCRIPTION
list all the commands
See code: @oclif/plugin-commands
heroku config
display the config vars for an app
USAGE
$ heroku config -a <value> [-r <value>] [-s] [-j]
FLAGS
-a, --app=<value> (required) app to run command against
-j, --json output config vars in json format
-r, --remote=<value> git remote of app to use
-s, --shell output config vars in shell format
DESCRIPTION
display the config vars for an app
See code: src/commands/config/index.ts
heroku config:edit [KEY]
interactively edit config vars
USAGE
$ heroku config:edit [KEY] -a <value> [-r <value>]
ARGUMENTS
KEY edit a single key
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
DESCRIPTION
interactively edit config vars
This command opens the app config in a text editor set by $VISUAL or $EDITOR.
Any variables added/removed/changed will be updated on the app after saving
and closing the file.
EXAMPLES
# edit with vim
$ EDITOR="vim" heroku config:edit
# edit with emacs
$ EDITOR="emacs" heroku config:edit
# edit with pico
$ EDITOR="pico" heroku config:edit
# edit with atom editor
$ VISUAL="atom --wait" heroku config:edit
See code: src/commands/config/edit.ts
heroku config:get KEY...
display a single config value for an app
USAGE
$ heroku config:get KEY...
ARGUMENTS
KEY key name of the config var value
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
-s, --shell output config vars in shell format
DESCRIPTION
display a single config value for an app
EXAMPLES
$ heroku config:get RAILS_ENV
production
See code: src/commands/config/get.ts
heroku config:set
set one or more config vars
USAGE
$ heroku config:set -a <value> [-r <value>]
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
DESCRIPTION
set one or more config vars
EXAMPLES
$ heroku config:set RAILS_ENV=staging
Setting config vars and restarting example... done, v10
RAILS_ENV: staging
$ heroku config:set RAILS_ENV=staging RACK_ENV=staging
Setting config vars and restarting example... done, v11
RAILS_ENV: staging
RACK_ENV: staging
See code: src/commands/config/set.ts
heroku config:unset
unset one or more config vars
USAGE
$ heroku config:unset -a <value> [-r <value>]
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
DESCRIPTION
unset one or more config vars
ALIASES
$ heroku config:remove
EXAMPLES
$ heroku config:unset RAILS_ENV
Unsetting RAILS_ENV and restarting example... done, v10
$ heroku config:unset RAILS_ENV RACK_ENV
Unsetting RAILS_ENV, RACK_ENV and restarting example... done, v10
See code: src/commands/config/unset.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
heroku container:login
log in to Heroku Container Registry
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:add HOSTNAME
add a domain to an app
USAGE
$ heroku domains:add HOSTNAME -a <value> [-h] [-c <value>] [-j]
[--wait] [-r <value>]
ARGUMENTS
HOSTNAME unique identifier of the domain or full hostname
FLAGS
-a, --app=<value> (required) app to run command against
-c, --cert=<value> the name of the SSL cert you want to use for this domain
-h, --help Show CLI help.
-j, --json output in json format
-r, --remote=<value> git remote of app to use
--wait
DESCRIPTION
add a domain to an app
EXAMPLES
$ heroku domains:add www.example.com
See code: src/commands/domains/add.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:info HOSTNAME
show detailed information for a domain on an app
USAGE
$ heroku domains:info 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
show detailed information for a domain on an app
EXAMPLES
$ heroku domains:info www.example.com
See code: src/commands/domains/info.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
display the log drains of an app
USAGE
$ heroku drains -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
display the log drains of an app
See code: src/commands/drains/index.ts
heroku drains:add URL
adds a log drain to an app
USAGE
$ heroku drains:add 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
adds a log drain to an app
See code: src/commands/drains/add.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 git:clone [DIRECTORY]
clones a heroku app to your local machine at DIRECTORY (defaults to app name)
USAGE
$ heroku git:clone [DIRECTORY] -a <value> [-r <value>]
ARGUMENTS
DIRECTORY where to clone the app
FLAGS
-a, --app=<value> (required) the Heroku app to use
-r, --remote=<value> the git remote to create, default "heroku"
DESCRIPTION
clones a heroku app to your local machine at DIRECTORY (defaults to app name)
EXAMPLES
$ heroku git:clone -a example
Cloning into 'example'...
remote: Counting objects: 42, done.
...
See code: src/commands/git/clone.ts
heroku git:remote
adds a git remote to an app repo
USAGE
$ heroku git:remote [-a <value>] [-r <value>]
FLAGS
-a, --app=<value> the Heroku app to use
-r, --remote=<value> the git remote to create
DESCRIPTION
adds a git remote to an app repo
extra arguments will be passed to git remote add
EXAMPLES
# set git remote heroku to https://git.heroku.com/example.git
$ heroku git:remote -a example
# set git remote heroku-staging to https://git.heroku.com/example.git
$ heroku git:remote --remote heroku-staging -a example
See code: src/commands/git/remote.ts
heroku help [COMMANDS]
Display help for heroku.
USAGE
$ heroku help [COMMANDS] [-n]
ARGUMENTS
COMMANDS Command to show help for.
FLAGS
-n, --nested-commands Include all nested commands in the output.
DESCRIPTION
Display help for heroku.
See code: @oclif/plugin-help
heroku keys
display your SSH keys
USAGE
$ heroku keys [--json] [-l]
FLAGS
-l, --long display full SSH keys
--json output in json format
DESCRIPTION
display your SSH keys
See code: src/commands/keys/index.ts
heroku keys:add [KEY]
add an SSH key for a user
USAGE
$ heroku keys:add [KEY] [-y]
ARGUMENTS
KEY absolute path to the key located on disk. If omitted, we use the default
rsa key.
FLAGS
-y, --yes automatically answer yes for all prompts
DESCRIPTION
add an SSH key for a user
EXAMPLES
$ heroku keys:add
Could not find an existing public key.
Would you like to generate one? [Yn] y
Generating new SSH public key.
Uploading SSH public key /.ssh/id_rsa.pub... done
$ heroku keys:add /my/key.pub
Uploading SSH public key /my/key.pub... done
See code: src/commands/keys/add.ts
heroku keys:clear
remove all SSH keys for current user
USAGE
$ heroku keys:clear
DESCRIPTION
remove all SSH keys for current user
See code: src/commands/keys/clear.ts
heroku keys:remove KEY
remove an SSH key from the user
USAGE
$ heroku keys:remove KEY
ARGUMENTS
KEY email address of the user
DESCRIPTION
remove an SSH key from the user
EXAMPLES
$ heroku keys:remove email@example.com
Removing email@example.com SSH key... done
See code: src/commands/keys/remove.ts
heroku labs
list experimental features
USAGE
$ heroku labs [-a <value>] [-r <value>] [--json]
FLAGS
-a, --app=<value> app to run command against
-r, --remote=<value> git remote of app to use
--json display as json
DESCRIPTION
list experimental features
See code: src/commands/labs/index.ts
heroku labs:disable FEATURE
disables an experimental feature
USAGE
$ heroku labs:disable FEATURE [-a <value>] [-r <value>] [--confirm
<value>]
ARGUMENTS
FEATURE unique identifier or name of the account feature
FLAGS
-a, --app=<value> app to run command against
-r, --remote=<value> git remote of app to use
--confirm=<value>
DESCRIPTION
disables an experimental feature
See code: src/commands/labs/disable.ts
heroku labs:enable FEATURE
enables an experimental feature
USAGE
$ heroku labs:enable FEATURE [-a <value>] [-r <value>]
ARGUMENTS
FEATURE unique identifier or name of the account feature
FLAGS
-a, --app=<value> app to run command against
-r, --remote=<value> git remote of app to use
DESCRIPTION
enables an experimental feature
See code: src/commands/labs/enable.ts
heroku labs:info FEATURE
show feature info
USAGE
$ heroku labs:info FEATURE [-a <value>] [-r <value>] [--json]
ARGUMENTS
FEATURE unique identifier or name of the account feature
FLAGS
-a, --app=<value> app to run command against
-r, --remote=<value> git remote of app to use
--json display as json
DESCRIPTION
show feature info
See code: src/commands/labs/info.ts
heroku local [PROCESSNAME]
run heroku app locally
USAGE
$ heroku local [PROCESSNAME] [-f <value>] [-e <value>] [-p
<value>]
ARGUMENTS
PROCESSNAME name of the process
FLAGS
-e, --env=<value> location of env file (defaults to .env)
-f, --procfile=<value> use a different Procfile
-p, --port=<value> port to listen on
DESCRIPTION
run heroku app locally
Start the application specified by a Procfile (defaults to ./Procfile)
ALIASES
$ heroku local:start
EXAMPLES
$ heroku local
$ heroku local web
$ heroku local web=2
$ heroku local web=1,worker=2
See code: src/commands/local/index.ts
heroku local:run
run a one-off command
USAGE
$ heroku local:run [-e <value>] [-p <value>]
FLAGS
-e, --env=<value>
-p, --port=<value>
DESCRIPTION
run a one-off command
EXAMPLES
$ heroku local:run bin/migrate
See code: src/commands/local/run.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 logs
display recent log output
USAGE
$ heroku logs -a <value> [-r <value>] [-n <value>] [-d <value>]
[-s <value>] [-t] [--force-colors]
FLAGS
-a, --app=<value> (required) app to run command against
-d, --dyno=<value> only show output from this dyno type (such as "web" or
"worker")
-n, --num=<value> number of lines to display
-r, --remote=<value> git remote of app to use
-s, --source=<value> only show output from this source (such as "app" or
"heroku")
-t, --tail continually stream logs
--force-colors force use of colors (even on non-tty output)
DESCRIPTION
display recent log output
disable colors with --no-color, HEROKU_LOGS_COLOR=0, or HEROKU_COLOR=0
EXAMPLES
$ heroku logs --app=my-app
$ heroku logs --num=50
$ heroku logs --dyno=web --app=my-app
$ heroku logs --app=my-app --tail
See code: src/commands/logs.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:add EMAIL
adds a user to a team
USAGE
$ heroku members:add EMAIL -r <value> -t <value>
ARGUMENTS
EMAIL email address of the team member
FLAGS
-r, --role=<value> (required) member role (admin, collaborator, member,
owner)
-t, --team=<value> (required) team to use
DESCRIPTION
adds a user to a team
See code: src/commands/members/add.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 members:set
sets a members role in a team
USAGE
$ heroku members:set -r <value> -t <value>
FLAGS
-r, --role=<value> (required) member role (admin, collaborator, member,
owner)
-t, --team=<value> (required) team to use
DESCRIPTION
sets a members role in a team
See code: src/commands/members/set.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 orgs
list the teams that you are a member of
USAGE
$ heroku orgs [--json] [--enterprise]
FLAGS
--enterprise filter by enterprise teams
--json output in json format
DESCRIPTION
list the teams that you are a member of
See code: src/commands/orgs/index.ts
heroku orgs:open
open the team interface in a browser window
USAGE
$ heroku orgs:open -t <value>
FLAGS
-t, --team=<value> (required) team to use
DESCRIPTION
open the team interface in a browser window
See code: src/commands/orgs/open.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 public schema
defaults to saving the latest database to
DATABASE_URL
-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:bloat [DATABASE]
show table and index bloat in your database ordered by most wasteful
USAGE
$ heroku pg:bloat [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 table and index bloat in your database ordered by most wasteful
See code: src/commands/pg/bloat.ts
heroku pg:blocking [DATABASE]
display queries holding locks other queries are waiting to be released
USAGE
$ heroku pg:blocking [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
display queries holding locks other queries are waiting to be released
See code: src/commands/pg/blocking.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:copy SOURCE TARGET
copy all data from source db to target
USAGE
$ heroku pg:copy SOURCE TARGET -a <value> [--wait-interval <value>]
[--verbose] [--confirm <value>] [-r <value>]
ARGUMENTS
SOURCE config var exposed to the owning app containing the source database
URL
TARGET config var exposed to the owning app containing the target database
URL
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
--confirm=<value>
--verbose
--wait-interval=<value>
DESCRIPTION
copy all data from source db to target
See code: src/commands/pg/copy.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:info [DATABASE]
show database information
USAGE
$ heroku pg:info [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 all databases.
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
DESCRIPTION
show database information
ALIASES
$ heroku pg
See code: src/commands/pg/info.ts
heroku pg:kill PID [DATABASE]
kill a query
USAGE
$ heroku pg:kill PID [DATABASE] -a <value> [-f] [-r <value>]
ARGUMENTS
PID ID of the process
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
kill a query
See code: src/commands/pg/kill.ts
heroku pg:killall [DATABASE]
terminates all connections for all credentials
USAGE
$ heroku pg:killall [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
terminates all connections for all credentials
See code: src/commands/pg/killall.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:locks [DATABASE]
display queries with active locks
USAGE
$ heroku pg:locks [DATABASE] -a <value> [-t] [-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
-t, --truncate truncates queries to 40 characters
DESCRIPTION
display queries with active locks
See code: src/commands/pg/locks.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:outliers [DATABASE]
show 10 queries that have longest execution time in aggregate
USAGE
$ heroku pg:outliers [DATABASE] -a <value> [--reset] [-t] [-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, --num=<value> the number of queries to display (default: 10)
-r, --remote=<value> git remote of app to use
-t, --truncate truncate queries to 40 characters
--reset resets statistics gathered by pg_stat_statements
DESCRIPTION
show 10 queries that have longest execution time in aggregate
See code: src/commands/pg/outliers.ts
heroku pg:promote DATABASE
sets DATABASE as your DATABASE_URL
USAGE
$ heroku pg:promote 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::`
FLAGS
-a, --app=<value> (required) app to run command against
-f, --force
-r, --remote=<value> git remote of app to use
DESCRIPTION
sets DATABASE as your DATABASE_URL
See code: src/commands/pg/promote.ts
heroku pg:ps [DATABASE]
view active queries with execution time
USAGE
$ heroku pg:ps [DATABASE] -a <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
DESCRIPTION
view active queries with execution time
See code: src/commands/pg/ps.ts
heroku pg:psql [DATABASE]
open a psql shell to the database
USAGE
$ heroku pg:psql [DATABASE] -a <value> [-c <value>] [-f <value>]
[--credential <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, --command=<value> SQL command to run
-f, --file=<value> SQL file to run
-r, --remote=<value> git remote of app to use
--credential=<value> credential to use
DESCRIPTION
open a psql shell to the database
ALIASES
$ heroku psql
See code: src/commands/pg/psql.ts
heroku pg:pull SOURCE TARGET
pull Heroku database into local or remote database
USAGE
$ heroku pg:pull SOURCE TARGET -a <value> [--exclude-table-data
<value>] [-r <value>]
ARGUMENTS
SOURCE 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.
TARGET PostgreSQL connection string for the target database
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
--exclude-table-data=<value> tables for which data should be excluded
(use ';' to split multiple names)
DESCRIPTION
pull Heroku database into local or remote database
Pull from SOURCE into TARGET.
TARGET must be one of:
* a database name (i.e. on a local PostgreSQL server) => TARGET must not
exist and will be created
* a fully qualified URL to a local PostgreSQL server => TARGET must not
exist and will be created
* a fully qualified URL to a remote PostgreSQL server => TARGET must exist
and be empty
To delete a local database run dropdb TARGET.
To create an empty remote database, run createdb with connection command-line
options (run createdb --help for details).
EXAMPLES
# pull Heroku DB named postgresql-swimmingly-100 into local DB mylocaldb
that must not exist
$ heroku pg:pull postgresql-swimmingly-100 mylocaldb --app sushi
# pull Heroku DB named postgresql-swimmingly-100 into empty remote DB at
postgres://myhost/mydb
$ heroku pg:pull postgresql-swimmingly-100 postgres://myhost/mydb --app \
sushi
See code: src/commands/pg/pull.ts
heroku pg:push SOURCE TARGET
push local or remote into Heroku database
USAGE
$ heroku pg:push SOURCE TARGET -a <value> [--exclude-table-data
<value>] [-r <value>]
ARGUMENTS
SOURCE PostgreSQL connection string for the source database
TARGET 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
--exclude-table-data=<value> tables for which data should be excluded
(use ';' to split multiple names)
DESCRIPTION
push local or remote into Heroku database
Push from SOURCE into TARGET. TARGET must be empty.
To empty a Heroku database for push run heroku pg:reset
SOURCE must be either the name of a database existing on your localhost or the
fully qualified URL of a remote database.
EXAMPLES
# push mylocaldb into a Heroku DB named postgresql-swimmingly-100
$ heroku pg:push mylocaldb postgresql-swimmingly-100 --app sushi
# push remote DB at postgres://myhost/mydb into a Heroku DB named
postgresql-swimmingly-100
$ heroku pg:push postgres://myhost/mydb postgresql-swimmingly-100 --app \
sushi
See code: src/commands/pg/push.ts
heroku pg:reset [DATABASE]
delete all data in DATABASE
USAGE
$ heroku pg:reset [DATABASE] -a <value> [-e <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>
-e, --extensions=<value> comma-separated list of extensions to pre-install in
the public schema
-r, --remote=<value> git remote of app to use
DESCRIPTION
delete all data in DATABASE
See code: src/commands/pg/reset.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
heroku pg:unfollow DATABASE
stop a replica from following and make it a writeable database
USAGE
$ heroku pg:unfollow 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::`
FLAGS
-a, --app=<value> (required) app to run command against
-c, --confirm=<value>
-r, --remote=<value> git remote of app to use
DESCRIPTION
stop a replica from following and make it a writeable database
See code: src/commands/pg/unfollow.ts
heroku pg:upgrade [DATABASE]
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 app dynos
USAGE
$ heroku ps:restart [DYNO] -a <value> [-r <value>]
ARGUMENTS
DYNO ID of the dyno
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
DESCRIPTION
restart app dynos
ALIASES
$ heroku dyno:restart
EXAMPLES
$ heroku ps:restart web.1
$ heroku ps:restart web
$ heroku ps:restart
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 app dyno
USAGE
$ heroku ps:stop DYNO -a <value> [-r <value>]
ARGUMENTS
DYNO ID of the dyno
FLAGS
-a, --app=<value> (required) app to run command against
-r, --remote=<value> git remote of app to use
DESCRIPTION
stop app dyno
ALIASES
$ heroku dyno:stop
$ heroku ps:kill
$ heroku dyno:kill
EXAMPLES
$ heroku ps:stop run.1828
$ heroku ps:stop 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: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 release ID.
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 one 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 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> [-s <value>] [--region <value>]
[--cidr <value>] [--data-cidr <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
--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
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 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 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