> ## 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.

# Delete entity records

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

Deletes every record in one of the app's entities that matches a filter, and returns how many it deleted.

Send the filter as the body, written the same way as the `q` parameter of [List entity records](/api-reference/list-entity-records). For example, `{"status": "cancelled"}` deletes every cancelled record. The body is required, and an empty object, `{}`, deletes every record in the entity.

Row-level security applies, so only the matching records the entity's `rls` delete rule lets you remove are deleted. The rest are left alone rather than failing the call.

The records move to the entity's trash rather than being erased. Bring them back with [Restore entity records](/api-reference/restore-entity-records), or erase one for good with [Permanently delete entity record](/api-reference/permanently-delete-entity-record).

Unlike [Delete entity record](/api-reference/delete-entity-record), this doesn't trigger the app's webhooks, automations, or workflows.

<Note>This endpoint accepts a personal API key belonging to a user with access to the app, or a workspace API key, which acts as the workspace owner. A read-only key is refused.</Note>

Runs as your user in this app, so the app's access rules decide which records you can read or change.



## OpenAPI

````yaml /developers/references/app-management/app-management-openapi.json delete /api/apps/{app_id}/entities/{entity_name}
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}/entities/{entity_name}:
    delete:
      summary: Delete entity records
      description: >-
        <Info>This API is in beta. Endpoints, fields, and behavior may still
        change, so avoid depending on it in production.</Info>


        Deletes every record in one of the app's entities that matches a filter,
        and returns how many it deleted.


        Send the filter as the body, written the same way as the `q` parameter
        of [List entity records](/api-reference/list-entity-records). For
        example, `{"status": "cancelled"}` deletes every cancelled record. The
        body is required, and an empty object, `{}`, deletes every record in the
        entity.


        Row-level security applies, so only the matching records the entity's
        `rls` delete rule lets you remove are deleted. The rest are left alone
        rather than failing the call.


        The records move to the entity's trash rather than being erased. Bring
        them back with [Restore entity
        records](/api-reference/restore-entity-records), or erase one for good
        with [Permanently delete entity
        record](/api-reference/permanently-delete-entity-record).


        Unlike [Delete entity record](/api-reference/delete-entity-record), this
        doesn't trigger the app's webhooks, automations, or workflows.


        <Note>This endpoint accepts a personal API key belonging to a user with
        access to the app, or a workspace API key, which acts as the workspace
        owner. A read-only key is refused.</Note>


        Runs as your user in this app, so the app's access rules decide which
        records you can read or change.
      operationId: delete_entities_api_apps__app_id__entities__entity_name__delete
      parameters:
        - name: app_id
          in: path
          required: true
          schema:
            type: string
            description: ID of the app that owns the entity.
            title: App Id
          description: ID of the app that owns the entity.
          example: 6820f3a4e7b91d003c45a1f2
        - name: entity_name
          in: path
          required: true
          schema:
            type: string
            description: >-
              Name of the entity, exactly as [List entity
              schemas](/api-reference/list-entity-schemas) reports it. Don't
              pass `User` here. It doesn't fail, but it reads and writes a
              separate, disconnected set of records stored under that name, not
              the app's real user accounts, which are managed through their own
              endpoints.
            title: Entity Name
          description: >-
            Name of the entity, exactly as [List entity
            schemas](/api-reference/list-entity-schemas) reports it. Don't pass
            `User` here. It doesn't fail, but it reads and writes a separate,
            disconnected set of records stored under that name, not the app's
            real user accounts, which are managed through their own endpoints.
          example: Invoice
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              additionalProperties: true
              title: DeleteEntityRecords
              description: >-
                Filter selecting the records to delete, in the same form as `q`.
                Send `{}` to delete every record in the entity.
            example:
              status: cancelled
      responses:
        '200':
          description: How many records were deleted.
          content:
            application/json:
              schema:
                type: object
                additionalProperties: true
                title: DeleteEntityRecordsResponse
                description: How many records were deleted.
                properties:
                  success:
                    type: boolean
                    title: Success
                    description: >-
                      Always `true`. A delete that doesn't happen returns an
                      error instead.
                    example: true
                  deleted:
                    description: >-
                      Number of records moved to the trash. `0` when no record
                      matched the filter.
                    example: 3
                    title: Deleted
                    type: integer
                required:
                  - success
                  - deleted
        '400':
          description: >-
            The filter isn't one Base44 can run, for example an unknown
            operator. A filter on the values of an encrypted field returns code
            `entity_field_not_queryable`.
        '401':
          description: Missing or invalid credentials.
        '403':
          description: You don't have access to this app, or your API key is read-only.
        '404':
          description: >-
            App not found, the app has no entity with this name, or the entity
            is `User`, whose records can't be deleted in bulk.
        '422':
          description: The body is missing, or isn't a JSON object.
        '429':
          description: >-
            Rate limit exceeded. The base limit is 30 requests every 30 seconds.
            See [Rate
            limits](/developers/references/apps-api/get-started/rate-limits) for
            the multiplier your plan gets.
        '503':
          description: >-
            Database temporarily unavailable (`database_unavailable`): the data
            cluster did not answer in time. Retry after the `Retry-After`
            seconds.
          headers:
            Retry-After:
              description: Seconds to wait before retrying.
              schema:
                type: integer
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StandardErrorEnvelope'
              examples:
                database_unavailable:
                  summary: database_unavailable
                  value:
                    error:
                      code: database_unavailable
                      message: Database temporarily unavailable, please retry
                      details: {}
      security:
        - PersonalAccessTokenAuth:
            - full_access
        - WorkspaceApiKeyAuth:
            - full_access
        - WorkspaceApiKeyBearerAuth:
            - full_access
components:
  schemas:
    StandardErrorEnvelope:
      properties:
        error:
          $ref: '#/components/schemas/StandardError'
          description: What went wrong.
      type: object
      required:
        - error
      title: StandardErrorEnvelope
      description: The error body returned in the standard envelope.
    StandardError:
      properties:
        code:
          type: string
          title: Code
          description: >-
            Stable machine-readable cause of the failure. Match on this, not on
            `message`.
          example: not_found
        message:
          type: string
          title: Message
          description: Human-readable explanation. It isn't a stable contract.
          example: App not found
        details:
          additionalProperties: true
          type: object
          title: Details
          description: >-
            Structured context for the failure, or an empty object when there's
            none.
          example: {}
      type: object
      required:
        - code
        - message
      title: StandardError
  securitySchemes:
    PersonalAccessTokenAuth:
      type: http
      scheme: bearer
      description: >-
        Personal access token, sent as `Authorization: Bearer <token>`. Each
        operation lists the permission it needs: `read_only` or `full_access`. A
        full-access token can call every operation. A read-only token can call
        only the operations that list `read_only`; anything else returns 403
        `read_only_credential_route_not_allowed`.
    WorkspaceApiKeyAuth:
      type: apiKey
      in: header
      name: api_key
      description: >-
        Workspace API key, sent as `api_key: <key>`. Each operation that accepts
        one lists what the key needs: a permission, `read_only` or
        `full_access`, like a personal access token, or a scope. A key without
        the scope gets 403 `workspace_api_key_scope_required`.
    WorkspaceApiKeyBearerAuth:
      type: http
      scheme: bearer
      description: >-
        Workspace API key, sent as `Authorization: Bearer <key>`. Accepted
        wherever `api_key` is, with the same permission.

````

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