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

# Sync entity schemas

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

Replaces the app's entire set of entities with the one you send, in a single call. This is what a deploy uses to make the app's live schema match its source.

<Warning>Send every entity the app should have. Any entity the app currently has that is missing from `entityNameToSchema` is deleted. Include `User` to keep its custom fields; leaving it out drops them.</Warning>

The response reports what changed, split into `created`, `updated`, and `deleted`. It also carries `warnings` for problems Base44 accepted instead of rejecting, so a 200 with a non-empty `warnings` means the sync applied but something in it is not doing what it looks like.

<Warning>This changes the app's live schema right away, but it does not change the entity definition in the app's source code. Base44 rebuilds the live schema from the source files whenever the app's code changes, which reverts anything you set here. Change the code itself when you need the edit to last.</Warning>

This endpoint is only available for apps whose source code you manage yourself. On an app whose code Base44 generates, it returns a 428. An entity that still has records cannot be deleted, so a sync that drops such an entity returns a 428 and changes nothing.

<Note>This endpoint accepts a personal API key, or a workspace API key with the `apps:deploy` scope.</Note>



## OpenAPI

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


        Replaces the app's entire set of entities with the one you send, in a
        single call. This is what a deploy uses to make the app's live schema
        match its source.


        <Warning>Send every entity the app should have. Any entity the app
        currently has that is missing from `entityNameToSchema` is deleted.
        Include `User` to keep its custom fields; leaving it out drops
        them.</Warning>


        The response reports what changed, split into `created`, `updated`, and
        `deleted`. It also carries `warnings` for problems Base44 accepted
        instead of rejecting, so a 200 with a non-empty `warnings` means the
        sync applied but something in it is not doing what it looks like.


        <Warning>This changes the app's live schema right away, but it does not
        change the entity definition in the app's source code. Base44 rebuilds
        the live schema from the source files whenever the app's code changes,
        which reverts anything you set here. Change the code itself when you
        need the edit to last.</Warning>


        This endpoint is only available for apps whose source code you manage
        yourself. On an app whose code Base44 generates, it returns a 428. An
        entity that still has records cannot be deleted, so a sync that drops
        such an entity returns a 428 and changes nothing.


        <Note>This endpoint accepts a personal API key, or a workspace API key
        with the `apps:deploy` scope.</Note>
      operationId: sync_schemas_api_apps__app_id__entity_schemas_put
      parameters:
        - name: app_id
          in: path
          required: true
          schema:
            type: string
            description: ID of the app whose entity schemas you want.
            title: App Id
          description: ID of the app whose entity schemas you want.
          example: 6820f3a4e7b91d003c45a1f2
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/SyncEntitySchemasRequest'
      responses:
        '200':
          description: What the sync created, updated, and deleted, plus any warnings.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SyncEntitySchemasResponse'
        '400':
          description: >-
            An entity name is empty or has characters other than letters,
            numbers, and underscores; a schema is not a valid JSON Schema; the
            `User` schema redeclares `email` or `full_name`; or a schema sets
            row-level security rules Base44 cannot enforce.
        '401':
          description: Missing or invalid credentials.
        '403':
          description: >-
            You don't have editor access to this app, or your workspace API key
            lacks the `apps:deploy` scope.
        '404':
          description: App not found.
        '409':
          description: >-
            The request is scoped to a feature branch. Entity schemas can only
            be changed on the main branch.
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
        '428':
          description: >-
            Base44 generates this app's source code, so this endpoint is not
            available for it; or an entity the sync would delete still has
            records.
components:
  schemas:
    SyncEntitySchemasRequest:
      properties:
        entityNameToSchema:
          additionalProperties:
            additionalProperties: true
            type: object
          type: object
          title: Entitynametoschema
          description: >-
            The app's complete set of entities, keyed by entity name. Each value
            is that entity's JSON Schema. Any entity the app currently has and
            this map does not is deleted.
          example:
            Invoice:
              name: Invoice
              properties:
                amount:
                  description: Total amount in cents
                  type: number
                status:
                  enum:
                    - draft
                    - sent
                    - paid
                  type: string
              required:
                - amount
              rls:
                read:
                  created_by: '{{user.email}}'
              type: object
      type: object
      required:
        - entityNameToSchema
      title: SyncEntitySchemasRequest
    SyncEntitySchemasResponse:
      properties:
        created:
          items:
            type: string
          type: array
          title: Created
          description: Entities that did not exist before and were added.
          example:
            - Invoice
        updated:
          items:
            type: string
          type: array
          title: Updated
          description: Entities that already existed and were replaced.
          example:
            - Customer
        deleted:
          items:
            type: string
          type: array
          title: Deleted
          description: Entities the app had and the request left out, which were removed.
          example:
            - LegacyOrder
        warnings:
          items:
            type: string
          type: array
          title: Warnings
          description: >-
            Problems Base44 accepted rather than rejected. Currently these are
            row-level security rules it cannot enforce on an entity that has no
            previous version, which a deploy usually carried over rather than
            wrote. The sync still applied.
          example:
            - >-
              Invalid RLS rule in Invoice: "properties.total.rls.delete" -
              field-level delete rules are not enforced - delete removes the
              whole record (there is no field-level delete gate); put the
              restriction in a top-level rls.delete instead
      type: object
      required:
        - created
        - updated
        - deleted
      title: SyncEntitySchemasResponse
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
      type: object
      title: HTTPValidationError
    ValidationError:
      properties:
        loc:
          items:
            anyOf:
              - type: string
              - type: integer
          type: array
          title: Location
        msg:
          type: string
          title: Message
        type:
          type: string
          title: Error Type
      type: object
      required:
        - loc
        - msg
        - type
      title: ValidationError
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: api_key
      description: Personal API key.

````