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

# List backend functions

> <Info>This API is in beta. Endpoints, fields, and behavior may still change, so avoid depending on it in production.</Info>

Returns the app's deployed backend functions, each with its code and the automations that run it.

Use it to pull the functions' source, for example before you change one and send it back with [Redeploy a backend function](/api-reference/redeploy-a-backend-function). Every function comes back in one response, with no paging.

This is limited to 60 requests per minute per app for each workspace's personal API keys, so every key in a workspace shares one allowance. Some workspaces have a different limit.

<Note>This endpoint accepts a personal API key belonging to a user with editor access to the app. A read-only key is refused even though this endpoint only reads, and workspace API keys are not accepted.</Note>

<Warning>The response includes fields beyond the ones documented here. Don't rely on undocumented response fields, as they can change at any time.</Warning>



## OpenAPI

````yaml /developers/references/app-management/app-management-openapi.json get /api/apps/{app_id}/backend-functions
openapi: 3.1.0
info:
  title: Base44 App Management API
  version: 1.0.0
servers:
  - url: https://app.base44.com
security:
  - PersonalAccessTokenAuth: []
paths:
  /api/apps/{app_id}/backend-functions:
    get:
      summary: List backend functions
      description: >-
        <Info>This API is in beta. Endpoints, fields, and behavior may still
        change, so avoid depending on it in production.</Info>


        Returns the app's deployed backend functions, each with its code and the
        automations that run it.


        Use it to pull the functions' source, for example before you change one
        and send it back with [Redeploy a backend
        function](/api-reference/redeploy-a-backend-function). Every function
        comes back in one response, with no paging.


        This is limited to 60 requests per minute per app for each workspace's
        personal API keys, so every key in a workspace shares one allowance.
        Some workspaces have a different limit.


        <Note>This endpoint accepts a personal API key belonging to a user with
        editor access to the app. A read-only key is refused even though this
        endpoint only reads, and workspace API keys are not accepted.</Note>


        <Warning>The response includes fields beyond the ones documented here.
        Don't rely on undocumented response fields, as they can change at any
        time.</Warning>
      operationId: list_functions_api_api_apps__app_id__backend_functions_get
      parameters:
        - name: app_id
          in: path
          required: true
          schema:
            type: string
            description: ID of the app the functions belong to.
            title: App Id
          description: ID of the app the functions belong to.
          example: 6820f3a4e7b91d003c45a1f2
      responses:
        '200':
          description: The app's backend functions.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BackendFunctions'
        '401':
          description: Missing or invalid credentials.
        '403':
          description: >-
            You don't have editor access to this app, the app is blocked, or
            your API key is read-only or a workspace API key.
        '404':
          description: App not found.
        '429':
          description: Rate limit exceeded.
components:
  schemas:
    BackendFunctions:
      properties:
        functions:
          items:
            $ref: '#/components/schemas/BackendFunction'
          type: array
          title: Functions
          description: >-
            The functions, with their code and automations. Empty when the app
            has none.
          example:
            - automations: []
              entry: main.ts
              files:
                - content: |
                    Deno.serve(async (req) => {
                      return Response.json({ ok: true });
                    });
                  path: main.ts
              name: sendWelcomeEmail
      type: object
      required:
        - functions
      title: BackendFunctions
      description: The app's deployed backend functions.
    BackendFunction:
      properties:
        name:
          type: string
          title: Name
          description: Name of the function. Nested functions have slashes in their name.
          example: sendWelcomeEmail
        entry:
          type: string
          title: Entry
          description: >-
            Path of the file the function starts from, one of the `path` values
            in `files`.
          example: main.ts
        files:
          items:
            $ref: '#/components/schemas/BackendFunctionFile'
          type: array
          title: Files
          description: The function's deployed code.
          example:
            - content: |
                Deno.serve(async (req) => {
                  return Response.json({ ok: true });
                });
              path: main.ts
        automations:
          items:
            $ref: '#/components/schemas/BackendFunctionAutomation'
          type: array
          title: Automations
          description: Automations that run the function. Empty when it has none.
          example:
            - description: Emails each user a summary of yesterday's tasks.
              function_args:
                digest: daily
              is_active: true
              name: Nightly digest
              type: scheduled
      type: object
      required:
        - name
        - entry
        - files
        - automations
      title: BackendFunction
      description: A backend function deployed for the app.
    BackendFunctionFile:
      properties:
        path:
          type: string
          title: Path
          description: Path of the file in the function's deployment.
          example: main.ts
        content:
          type: string
          title: Content
          description: The file's source.
          example: |
            Deno.serve(async (req) => {
              return Response.json({ ok: true });
            });
      type: object
      required:
        - path
        - content
      title: BackendFunctionFile
      description: One file of a backend function's code.
    BackendFunctionAutomation:
      properties:
        name:
          type: string
          title: Name
          description: Name of the automation.
          example: Nightly digest
        type:
          type: string
          enum:
            - scheduled
            - entity
            - connector
          title: Type
          description: >-
            What starts the automation. `scheduled` runs it on a schedule,
            `entity` when records of an entity change, and `connector` on an
            event from a connected service. Each automation also carries the
            settings for its type, such as its schedule or the entity it
            watches.
          example: scheduled
        description:
          anyOf:
            - type: string
            - type: 'null'
          title: Description
          description: What the automation is for, or `null` if none was given.
          example: Emails each user a summary of yesterday's tasks.
        function_args:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Function Args
          description: >-
            Arguments the automation passes to the function, or `null` when it
            passes none.
          example:
            digest: daily
        is_active:
          type: boolean
          title: Is Active
          description: Whether the automation runs (`true`) or is paused (`false`).
          example: true
      type: object
      required:
        - name
        - type
        - description
        - function_args
        - is_active
      title: BackendFunctionAutomation
      description: An automation that runs a backend function.
  securitySchemes:
    PersonalAccessTokenAuth:
      type: http
      scheme: bearer
      description: 'Personal access token, sent as `Authorization: Bearer <token>`.'

````

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