> ## Documentation Index
> Fetch the complete documentation index at: https://developers.liara.ir/llms.txt
> Use this file to discover all available pages before exploring further.

# List apps

> Lists your apps, newest first. With `teamID`, it lists the team's apps you have access to.



## OpenAPI

````yaml /spec/paas.yaml get /v1/projects
openapi: 3.0.1
info:
  title: Apps & Deployments
  version: 1.0.0
  description: >
    Create apps, deploy them, change their plans and settings, and read

    their logs, metrics and events.


    ## Identifying an app


    Most endpoints identify an app by its **name** (`project_id`, for

    example `my-app`). Some use its **ID** instead (`projectID`, the
    24-character

    `_id` returned when you create or list apps). Each endpoint says which one

    it expects.


    ## Deploying


    1. Upload your source code as a `.tar.gz` or `.zip` archive with
       `POST /v2/projects/{project_id}/sources`. You get a `sourceID`.
    2. Create a release with `POST /v2/projects/{project_id}/releases`, passing
       the `sourceID`. For `docker` apps you can pass a ready-made `image`
       instead.
    3. Follow the build with `GET /v2/releases/{releaseID}/build-logs` and
       check the release `state` with `GET /v1/releases/{releaseID}` until it's
       `READY` (or `FAILED`, `CANCELED`, `TIMEDOUT` or `UNHEALTHY`).

    ## Interactive shell (WebSocket)


    Open a shell in a running app over WebSocket:


    ```text

    wss://api.liara.ir/v1/exec?token=<api-token>&project_id=<app-name>&cmd=<command>

    ```


    - `token`: your API token.

    - `project_id`: the app's name.

    - `cmd`: the command to run, for example `/bin/bash`. URL-encode it.

    - `teamID` (optional): the team that owns the app. You need the `operate`
      or `manage` permission on the app.

    Everything you send is passed to the command's input, and its output is

    sent back to you. If the app has never been deployed successfully, you get

    the message `Service does not exist yet. You should have at least one

    successful release.` and the connection closes. The handshake fails with

    `401` for a missing or invalid token, `400` if `project_id` or `cmd` is

    missing or `teamID` is invalid, `403` without access to the team or app,

    and `404` if the app doesn't exist.


    ## Team permissions


    With `teamID`, each endpoint needs one of the project permissions it lists

    (`view`, `deploy`, `operate` or `manage`). A permission from your role or

    a resource permission on that app both count.
servers:
  - url: https://api.liara.ir
security:
  - bearerAuth: []
tags:
  - name: Apps
    description: Create, list, inspect and delete apps.
  - name: Configuration
    description: Environment variables, port, DNS servers, plans and scaling.
  - name: Settings
    description: >-
      Read-only filesystem, default subdomain, zero-downtime deployment and
      fixed outbound IP.
  - name: Deployments
    description: Upload source code, create releases, follow builds and roll back.
  - name: Logs, Metrics & Events
    description: Runtime logs, resource usage and lifecycle events.
  - name: Networks
    description: Private networks that apps and databases are created in.
paths:
  /v1/projects:
    get:
      tags:
        - Apps
      summary: List apps
      description: >-
        Lists your apps, newest first. With `teamID`, it lists the team's apps
        you have access to.
      operationId: listApps
      parameters:
        - $ref: '#/components/parameters/TeamID'
        - name: isManagedWordpress
          in: query
          required: false
          description: >-
            Send `true` to list only managed WordPress sites instead of regular
            apps.
          schema:
            type: string
            enum:
              - 'true'
      responses:
        '200':
          description: Your apps.
          content:
            application/json:
              schema:
                type: object
                properties:
                  projects:
                    type: array
                    items:
                      $ref: '#/components/schemas/AppSummary'
              example:
                projects:
                  - _id: '000000000000000000000050'
                    project_id: my-app
                    type: node
                    scale: 1
                    planID: small-g2
                    bundlePlanID: standard
                    status: ACTIVE
                    network:
                      _id: '000000000000000000000160'
                      name: my-network
                    isDeployed: true
                    created_at: '2026-01-01T08:00:00.000Z'
        '400':
          $ref: '#/components/responses/InvalidTeamID'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/TeamNotFound'
components:
  parameters:
    TeamID:
      name: teamID
      in: query
      required: false
      description: >-
        Run the request in the context of a team you belong to, instead of your
        personal account.
      schema:
        $ref: '#/components/schemas/ObjectID'
      example: '000000000000000000000002'
  schemas:
    AppSummary:
      type: object
      properties:
        _id:
          type: string
          description: The app's ID.
        project_id:
          type: string
          description: The app's name.
        type:
          $ref: '#/components/schemas/Platform'
        scale:
          type: integer
          description: '`1` if the app is on, `0` if it''s off.'
        planID:
          type: string
        bundlePlanID:
          type: string
        status:
          $ref: '#/components/schemas/AppStatus'
        network:
          type: object
          properties:
            _id:
              type: string
            name:
              type: string
        isDeployed:
          type: boolean
          description: Whether the app has ever been deployed.
        created_at:
          type: string
          format: date-time
    ObjectID:
      type: string
      pattern: ^[0-9a-fA-F]{24}$
      description: 24-character hexadecimal ID.
    Platform:
      type: string
      description: The app's platform.
      enum:
        - node
        - next
        - react
        - vue
        - angular
        - static
        - laravel
        - php
        - django
        - flask
        - python
        - netcore
        - dotnet
        - go
        - docker
    AppStatus:
      type: string
      description: >-
        `ACTIVE`: running normally. `FROZEN`: stopped, for example because the
        balance ran out. `UNFREEZING`: being reactivated. `CRASH_LOOP`: keeps
        crashing on start. `SUSPENDED`: suspended by Liara.
      enum:
        - ACTIVE
        - FROZEN
        - UNFREEZING
        - CRASH_LOOP
        - SUSPENDED
    Error:
      type: object
      description: Standard error body.
      properties:
        statusCode:
          type: integer
        error:
          type: string
          description: HTTP status text.
        message:
          type: string
          description: What went wrong.
        data:
          type: object
          nullable: true
          description: >-
            Extra details. When present, `code` is a stable, machine-readable
            error code.
          properties:
            code:
              type: string
    AuthError:
      type: object
      description: Error body returned when the API token is rejected.
      properties:
        error:
          type: string
  responses:
    InvalidTeamID:
      description: '`teamID` isn''t a valid ID.'
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            statusCode: 400
            error: Bad Request
            message: Invalid team ID.
            data: null
    Unauthorized:
      description: The API token is missing, invalid or expired.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/AuthError'
          example:
            error: Unauthorized.
    TeamNotFound:
      description: You sent a `teamID` for a team you aren't a member of.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            statusCode: 403
            error: Forbidden
            message: Team not found
            data:
              code: team_not_found
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: 'Send your API token as `Authorization: Bearer <api-token>`.'

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.