# List the account's web applications.

This function lists the account's web applications and their current
state.

Endpoint: GET /WebApp/list
Version: 11.138.0.19
Security: BasicAuth

## Response 200 fields (application/json):

  - `apiversion` (integer)
    The version of the API.
    Example: 3

  - `func` (string)
    The name of the method called.
    Example: "list"

  - `module` (string)
    The name of the module called.
    Example: "WebApp"

  - `result` (object)

  - `result.data` (array)
    The account's web applications.

  - `result.data.auto_recovery` (integer,null)
    Whether the scheduled health check may act on this
application: 1 if it may, 0 if the application
is to be left alone entirely, and null when it
follows the server-wide setting.

An application set to 0 is not checked at all, so
its health block stops being updated.

  - `result.data.build_command` (string,null)
    The application's configured build command, or null if it has no build step. Set from the preflight-suggested default at stage, and overridable via configure.
    Example: "npm run build"

  - `result.data.category` (string)
    The application's category. This determines which
lifecycle actions apply.

* static — The application builds to static files that the web server serves directly.
* server — The application runs a long-lived server process.
* other — Any other kind of application.
    Enum: "static", "server", "other"

  - `result.data.container_name` (string,null)
    The name of the deployed container backing this
application, or null while it is only staged.
Assigned by the deploy and unique per application
instance, so it identifies the exact deployed
record even when several applications share a
base name.
    Example: "my-app.bob.01"

  - `result.data.db` (object,null)
    The application's linked database, or null if none is configured.

  - `result.data.db.env_keys` (array)
    The environment variable names the database's
connection details are injected under, directly
into the deployed container's environment.
These are not part of this application's own
env field, and are never echoed back by any
call.
    Example: ["DB_NAME","DB_HOST","DB_PORT","DB_USER","DB_PASSWORD"]

  - `result.data.db.host` (string)
    The database server hostname.
    Example: "localhost"

  - `result.data.db.name` (string)
    The database name.
    Example: "example_my_app"

  - `result.data.db.origin` (string)
    How the application got this database.

* create — Provisioned by this application; remove
  deletes the database itself.
* link — An existing database this account owns
  independently; remove only detaches the
  dedicated dbuser created for it.
    Enum: "create", "link"

  - `result.data.db.port` (integer)
    The database server port.
    Example: 3306

  - `result.data.deployed` (boolean)
    Whether a deploy has put the application live. This is true once the application holds a container or a deploy has completed successfully, and false for a freshly staged application or one whose only deploy failed.

  - `result.data.deployname` (string,null)
    The name used to name the deployment, or null when it defaults to the application name.
    Example: "my-site"

  - `result.data.domain` (string)
    The domain the application is bound to. This is an existing domain on the account or an automatically generated temporary domain.
    Example: "my-app.example.com"

  - `result.data.env` (object)
    The application's environment variables.
    Example: {"NODE_ENV":"production"}

  - `result.data.env_editable` (boolean)
    Whether the environment may be set for this
application. The values are written to the
application's own .env, which lives in its
source tree, so a repository that would publish
that file withholds the feature: a configure
that sets env or env_text fails with an error_category
of env_not_editable. Derived from the source
tree on every call, so it changes as soon as the
repository does.
    Example: true

  - `result.data.env_status` (string)
    Why the environment is not editable, or ok
when it is. tracked means the repository tracks
.env; not_ignored means no committed
.gitignore rule covers it. Both are fixed by
the user in the repository, not through this
API.
    Enum: "ok", "tracked", "not_ignored"

  - `result.data.framework` (string,null)
    The application's detected or user-selected framework, or null if unknown.
    Example: "nextjs"

  - `result.data.health` (object,null)
    What the most recent health check found, or null
if the application has not been checked yet. This
is read from the last check rather than measured
when you call this function, so it is at most one
check interval old.

  - `result.data.health.action` (string)
    What would repair the cause, which is not
always a restart.

* none — Nothing should be done to the application.
* restart — Restarting it is a reasonable repair.
* rewire_proxy — Its reverse-proxy configuration needs rewriting.
* notify — Only a person can resolve this.
    Enum: "none", "restart", "rewire_proxy", "notify"

  - `result.data.health.cause` (string)
    What is wrong with the application.

* healthy — Nothing.
* stopped_by_user — You stopped it.
* deploying — A deploy is in progress.
* never_deployed — No deploy has ever succeeded.
* out_of_memory — It exceeded its memory limit and was killed.
* crash_on_boot — It has never started successfully since its last deploy.
* dead — It ran and then stopped.
* unit_missing — Its service definition is gone.
* wedged — It is running but not answering on its port.
* stale_proxy_port — Its reverse proxy points at a port it no longer uses.
* missing_include — It has no reverse-proxy configuration.
* port_unreachable — It is running but publishes no port.
* public_unreachable — It answers locally, and its domain does not.
* app_error — It answers requests with an error of its own.
* unknown — Nothing could be read about it.
    Enum: "healthy", "stopped_by_user", "deploying", "never_deployed", "out_of_memory", "crash_on_boot", "dead", "unit_missing", "wedged", "stale_proxy_port", "missing_include", "port_unreachable", "public_unreachable", "app_error", "unknown"

  - `result.data.health.checked_at` (string)
    When the check ran, in ISO 8601 format.
    Example: "2026-06-12T14:03:22.000Z"

  - `result.data.health.healthy_at` (string,null)
    When the application was last seen healthy, in ISO 8601 format, or null if it never has been. An application that has not been healthy since its last deploy has never started successfully, which a restart cannot fix.
    Example: "2026-06-12T13:58:04.000Z"

  - `result.data.health.incidents` (integer)
    How many incidents were recorded for this application in the last 24 hours. Only the most recent incidents are kept, so this figure stops climbing once enough of them have been recorded to show the pattern.
    Example: 3

  - `result.data.health.memory` (object,null)
    The application's own memory accounting at the time of the check, or null when neither a live figure nor a configured limit could be read.

  - `result.data.health.memory.limit_bytes` (integer,null)
    The memory limit, or null if it is not capped.
    Example: 536870912

  - `result.data.health.memory.oom_kills` (integer)
    How many times a process was killed for exceeding the limit during this run.
    Example: 1

  - `result.data.health.memory.peak_bytes` (integer,null)
    The highest memory use recorded during this run, or null once the run is over or if this server does not keep that figure.
    Example: 186912768

  - `result.data.health.oom_incidents` (integer)
    How many of the last 24 hours' incidents were the application exceeding its memory limit, counted over the same kept incidents as incidents. Past a few of these, raising the limit is the only thing that will help, and that is your decision.
    Example: 3

  - `result.data.health.restarts` (integer)
    How many times the service has been restarted, as the system's own retry counter reports it. Omitted when that counter could not be read.
    Example: 3

  - `result.data.health.state` (string)
    A summary of cause suitable for a status badge.

* healthy — Nothing is wrong.
* stopped — You stopped it.
* pending — It is deploying, or has never deployed.
* recovering — Something is wrong and a repair is available.
* needs_attention — Something is wrong that only you can resolve.
* unreachable — The application is fine and its domain is not.
* unknown — Nothing could be read about it.
    Enum: "healthy", "stopped", "pending", "recovering", "needs_attention", "unreachable", "unknown"

  - `result.data.last_deploy` (object,null)
    Information about the most recent deploy, or null if the application has never deployed.

  - `result.data.last_deploy.deploy_id` (string)
    The unique identifier of the deploy.
    Example: "dp-20260612-0001"

  - `result.data.last_deploy.error_category` (string)
    The failure category of a failed deploy. Absent for a successful deploy.
    Example: "build_failed"

  - `result.data.last_deploy.error_detail` (string)
    A short, single-line explanation of a failed deploy, limited to 2048 characters with control characters removed. Absent when there is nothing to add.
    Example: "The build command exited with code 1."

  - `result.data.last_deploy.error_phase` (string)
    The stage of the deploy that failed. Absent for a successful deploy and for a deploy recorded before this field existed.
    Enum: "source", "pull", "provision", "build", "output", "config_sync", "recreate", "start", "listen", "internal"

  - `result.data.last_deploy.error_reason` (string)
    What went wrong within the failed phase, for example oom_suspected, timeout, nonzero_exit, toolchain_missing, disk_quota, image_pull, ea_podman_missing, session, create_failed, not_listening or worker_exception. The set can grow; treat an unrecognized value as unknown.
    Example: "oom_suspected"

  - `result.data.last_deploy.result` (string)
    The result of the deploy.
    Enum: "success", "failed"

  - `result.data.last_deploy.timestamp` (string)
    When the deploy finished, in ISO 8601 format.
    Example: "2026-06-12T14:03:22.000Z"

  - `result.data.mode` (string,null)
    The application's run mode. Only meaningful for the server category; null otherwise.
    Enum: "production", "development"

  - `result.data.name` (string)
    The application's name (slug), unique across the
account. Use this value to address the application
in the per-app operations (configure, deploy,
and the lifecycle verbs). A name is assigned at
stage; staging a name a deployed application
already uses registers the new one under the next
free -N, so each application keeps a
distinct name.
    Example: "my-app"

  - `result.data.package_manager` (string)
    The package manager the deploy uses to install
dependencies and run scripts. It is detected from
the source's packageManager field, a lockfile,
or the default (npm).
    Enum: "npm", "yarn", "pnpm", "bun"

  - `result.data.runtime` (string)
    The application's runtime identifier.
    Example: "nodejs"

  - `result.data.runtime_tag` (string)
    The runtime version tag.
    Example: "22"

  - `result.data.source` (object)
    The application's source information.

  - `result.data.source.branch` (string,null)
    The Git branch, or null for ZIP sources.
    Example: "main"

  - `result.data.source.type` (string)
    The source type.

* zip — An uploaded archive.
* git — A Git repository.
    Enum: "zip", "git"

  - `result.data.source.url` (string,null)
    The Git repository URL, or null for ZIP sources.
    Example: "https://github.com/example/my-app.git"

  - `result.data.staged` (boolean)
    Whether the application's source is present in the staging area. This is true after the source is uploaded or cloned and until the application is deleted.
    Example: true

  - `result.data.startup_command` (string,null)
    The application's configured startup command, or null for a static application (which has no running process to start). Set from the preflight-suggested default at stage, and overridable via configure.
    Example: "npm run start"

  - `result.data.status` (string)
    The application's current status.

* created — Registered but never deployed.
* deploying — A deploy is in progress.
* running — The application is live.
* stopped — The application is stopped.
* errored — The last action failed.
    Enum: "created", "deploying", "running", "stopped", "errored"

  - `result.data.url` (string)
    The application's live HTTPS URL.
    Example: "https://my-app.example.com"

  - `result.data.use_existing_domain` (integer)
    Whether the application was confirmed onto a domain the account already used, replacing what that domain served. 0 for an application serving a domain it created itself. See https://go.cpanel.net/docroot2proxy.

  - `result.errors` (array,null)
    List of errors if the API failed.

  - `result.messages` (array,null)
    List of messages generated by the API.

  - `result.metadata` (object)

  - `result.status` (integer)
    - 1 - Success.
- 0 - Failed. Check the errors field for more details.
    Enum: 0, 1

  - `result.warnings` (array,null)
    List of warnings generated by the API. Warnings describe non-critical failures or other problematic conditions noted while running a API.