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

# Run security scan

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

Scans the app for security problems and returns the findings.

The response is the same shape as [Get security scan](/api-reference/get-security-scan), and which of two things you get depends on whether Base44 already has a current answer:

- If the last scan still matches the app, you get it straight back with `status` set to `up_to_date`, and the `X-Scan-Source` response header set to `cache`. Nothing is re-scanned.
- Otherwise a scan starts in the background and you get `status` set to `scanning` with the previous findings still in `result`, and `X-Scan-Source` set to `async`. Poll [Get security scan](/api-reference/get-security-scan) while `status` is `pending` or `scanning`, since both mean a scan is still going to settle.

This is how a request made with a workspace API key is answered. A request made with a personal access token always takes the second path, even when the last scan still matches the app, and that scan then settles on the matching result.

So a 200 here does not mean a scan ran, and it does not mean the findings in the body are current. Read `status` and the `X-Scan-Source` header to tell the two apart.

A real scan reads the app's code and runs a language model over it, which takes a while and is why it runs in the background rather than on your connection. This endpoint is limited to 5 requests per minute.

<Note>Findings are only ever as fresh as the scan that produced them. On `out_of_date` the app has changed since, so treat the findings as a previous snapshot and run a new scan before acting on them.</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 post /api/apps/{app_id}/security/scan
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}/security/scan:
    post:
      summary: Run security scan
      description: >-
        <Info>This API is in beta. Endpoints, fields, and behavior may still
        change, so avoid depending on it in production.</Info>


        Scans the app for security problems and returns the findings.


        The response is the same shape as [Get security
        scan](/api-reference/get-security-scan), and which of two things you get
        depends on whether Base44 already has a current answer:


        - If the last scan still matches the app, you get it straight back with
        `status` set to `up_to_date`, and the `X-Scan-Source` response header
        set to `cache`. Nothing is re-scanned.

        - Otherwise a scan starts in the background and you get `status` set to
        `scanning` with the previous findings still in `result`, and
        `X-Scan-Source` set to `async`. Poll [Get security
        scan](/api-reference/get-security-scan) while `status` is `pending` or
        `scanning`, since both mean a scan is still going to settle.


        This is how a request made with a workspace API key is answered. A
        request made with a personal access token always takes the second path,
        even when the last scan still matches the app, and that scan then
        settles on the matching result.


        So a 200 here does not mean a scan ran, and it does not mean the
        findings in the body are current. Read `status` and the `X-Scan-Source`
        header to tell the two apart.


        A real scan reads the app's code and runs a language model over it,
        which takes a while and is why it runs in the background rather than on
        your connection. This endpoint is limited to 5 requests per minute.


        <Note>Findings are only ever as fresh as the scan that produced them. On
        `out_of_date` the app has changed since, so treat the findings as a
        previous snapshot and run a new scan before acting on them.</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: run_scan_api_apps__app_id__security_scan_post
      parameters:
        - name: app_id
          in: path
          required: true
          schema:
            type: string
            description: ID of the app.
            title: App Id
          description: ID of the app.
          example: 6820f3a4e7b91d003c45a1f2
        - name: language
          in: query
          required: false
          schema:
            enum:
              - en
              - ja
              - de
              - es
              - fr
              - pt
              - hu
            type: string
            description: >-
              Language to return generated text in, as a lowercase two-letter
              code. An unsupported value is rejected with a 422.
            default: en
            title: Language
          description: >-
            Language to return generated text in, as a lowercase two-letter
            code. An unsupported value is rejected with a 422.
          example: de
      responses:
        '200':
          description: The findings, or the state of the scan that just started.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SecurityScanStatus'
          headers:
            X-Scan-Source:
              description: >-
                Where the response came from. `cache` means the existing result
                was returned and nothing was re-scanned. `async` means a scan
                started in the background and `result` holds the previous
                findings.
              schema:
                type: string
                enum:
                  - cache
                  - async
                example: cache
        '401':
          description: Missing or invalid credentials.
        '403':
          description: You don't have access to this app.
        '404':
          description: App not found.
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
        '429':
          description: Rate limit exceeded (5 requests per minute).
        '503':
          description: >-
            Sandbox temporarily unavailable (`sandbox_unavailable`): the app's
            sandbox could not be created or reached. Retry after the
            `Retry-After` seconds.
          content:
            application/json:
              examples:
                sandbox_unavailable:
                  summary: sandbox_unavailable
                  value:
                    error:
                      code: sandbox_unavailable
                      message: Sandbox temporarily unavailable, please retry
                      details: {}
              schema:
                $ref: '#/components/schemas/StandardErrorEnvelope'
      security:
        - PersonalAccessTokenAuth:
            - full_access
        - WorkspaceApiKeyAuth:
            - full_access
        - WorkspaceApiKeyBearerAuth:
            - full_access
components:
  schemas:
    SecurityScanStatus:
      properties:
        status:
          type: string
          title: Status
          description: >-
            Where the scan is. `up_to_date` means `result` reflects the app as
            it is now. `out_of_date` means the app changed since the last scan,
            so `result` is stale or absent. `none` means the app has never been
            scanned. `pending` means a scan is queued and `scanning` means one
            is running, and both can carry an earlier `result` while you wait.
            `scan_failed` means the last scan died, so run another.
          example: up_to_date
        result:
          anyOf:
            - $ref: '#/components/schemas/SecurityScanFindings'
            - type: 'null'
          description: >-
            What the scan found, or `null` when there is nothing to show. It is
            `null` on `none`, and also on `out_of_date` when the last scan came
            from a different version of the scanner, in which case only a fresh
            scan produces findings.
        static_code_enabled:
          type: boolean
          title: Static Code Enabled
          description: >-
            Whether code-reading analysis is switched on for this app (`true`)
            or not (`false`). When it is `false`, `result.static_code_findings`
            comes back as an empty list, so this field is the only way to tell
            an analysis that found nothing from one that never ran.
          example: true
        stream:
          anyOf:
            - $ref: '#/components/schemas/SecurityScanStreamProgress'
            - type: 'null'
          description: >-
            Partial results from a scan that is still running, or `null` when
            there are none. It appears only while `status` is `scanning`.
            `result` above keeps its own meaning — the previous scan's findings
            — so ignoring this field preserves the earlier behavior of waiting
            for the whole scan.
      type: object
      required:
        - status
        - result
        - static_code_enabled
        - stream
      title: SecurityScanStatus
      description: The state of an app's security scan, and its findings when it has any.
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
      type: object
      title: HTTPValidationError
    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.
    SecurityScanFindings:
      properties:
        analysis_summary:
          type: string
          title: Analysis Summary
          description: Plain-language summary of the scan.
          example: >-
            The app exposes orders to any signed-in user and has one hardcoded
            credential.
        rls_recommendations:
          items:
            $ref: '#/components/schemas/SecurityRlsRecommendation'
          type: array
          title: Rls Recommendations
          description: >-
            Entities whose row-level security should change, one entry per
            entity.
          example: []
        hardcoded_secrets:
          items:
            $ref: '#/components/schemas/SecurityHardcodedSecret'
          type: array
          title: Hardcoded Secrets
          description: Credentials written into the app's code.
          example: []
        backend_functions:
          items:
            $ref: '#/components/schemas/SecurityBackendFunctionIssue'
          type: array
          title: Backend Functions
          description: Problems found in the app's backend functions.
          example: []
        open_backend_functions:
          anyOf:
            - items:
                $ref: '#/components/schemas/SecurityOpenBackendFunction'
              type: array
            - type: 'null'
          title: Open Backend Functions
          description: >-
            On an app that doesn't require login, every backend function with
            what it can do, read from its code, plus the security review's notes
            as `findings`. All are `low` and the Security tab shows them as one
            group. These replace `backend_functions` there. Empty on an app that
            requires login, `null` on a result recorded before Base44 collected
            them.
          example: []
        unlocked_user_fields:
          anyOf:
            - items:
                $ref: '#/components/schemas/SecurityUnlockedUserField'
              type: array
            - type: 'null'
          title: Unlocked User Fields
          description: >-
            Custom User fields that the app's access rules read
            (`{{user.data.<field>}}` or a `user_condition`) but that app users
            can change on their own record, so a user can set one to another
            tenant's value. A field is locked by a field-level `update` rule on
            the User entity that a non-editor can't meet. `null` for a caller
            outside the rollout, or on a result recorded before Base44 checked.
        exposed_fields:
          anyOf:
            - items:
                $ref: '#/components/schemas/SecurityExposedField'
              type: array
            - type: 'null'
          title: Exposed Fields
          description: >-
            Fields on entities that everyone who can open the app can read,
            which hold data a person would not want strangers to see, such as a
            client's email on a public testimonial. A field-level read rule
            hides the field and keeps the record public. `null` for a caller
            outside the rollout, or on a result recorded before Base44 checked.
        dependency_vulnerabilities:
          items:
            $ref: '#/components/schemas/SecurityDependencyVulnerability'
          type: array
          title: Dependency Vulnerabilities
          description: Known vulnerabilities in the app's npm dependencies.
          example: []
        static_code_findings:
          items:
            $ref: '#/components/schemas/SecurityStaticCodeFinding'
          type: array
          title: Static Code Findings
          description: >-
            Problems found by reading the app's code, listing only the findings
            that survived the scan's own second-pass check. It also leaves out
            findings that Base44's AI, asked to fix them, checked and concluded
            can't be exploited; such a finding comes back if its code changes.
            It is an empty list when code-reading analysis is switched off for
            the app, which is not the same as a clean result, so read
            `static_code_enabled` before concluding there is nothing to find.
          example: []
        header_recommendations:
          items:
            $ref: '#/components/schemas/SecurityHeaderRecommendation'
          type: array
          title: Header Recommendations
          description: >-
            Recommended changes to the published app's HTTP headers. These are
            computed from the app's current settings on every read rather than
            stored with the scan.
          example: []
        core_integration_recommendation:
          anyOf:
            - type: string
            - type: 'null'
          title: Core Integration Recommendation
          description: >-
            Whether the app is ready for Base44's [core integration
            protection](/developers/references/apps-api/sections/security#core-integration-protection).
            `no_restricted_usage` means nothing in the app needs it,
            `compatible` means turning it on with [Enable core integration
            protection](/api-reference/enable-core-integration-protection) is
            safe, `would_be_blocked` means it would break the app as written,
            and `publish_required` means the app has to be published before this
            can be judged. It is `null` when the answer does not apply to this
            app.
          example: compatible
        creator_email_exposure:
          anyOf:
            - $ref: '#/components/schemas/SecurityCreatorEmailExposure'
            - type: 'null'
          description: >-
            Set when the app's entity records include the email of the user who
            created each one (`created_by`) and someone other than that user can
            read them. Apps created before this changed still return the email
            unless `hide_entity_created_by` is on. `null` when the email is
            hidden, no one else can read the records, or the caller is outside
            the rollout.
        ignored_fingerprints:
          items:
            type: string
          type: array
          title: Ignored Fingerprints
          description: >-
            Fingerprints of the findings that have been
            [ignored](/developers/references/apps-api/sections/security#act-on-findings)
            with [Ignore security
            finding](/api-reference/ignore-security-finding). Those findings are
            still in their lists, so leave out any whose `fingerprint` appears
            here to see only the open ones. An entry that matches no finding
            here stays until the next scan drops it.
          example:
            - 3f9a1c0e8b7d4a6f2e5c9b1d0a8f7e6c5b4a3d2e1f0c9b8a7d6e5f4c3b2a1d0e
        scanned_at:
          anyOf:
            - type: string
              format: date-time
            - type: 'null'
          title: Scanned At
          description: >-
            When the scan that produced these findings ran, or `null` on a
            result recorded before Base44 stored the time.
          example: '2026-08-25T14:05:00Z'
      type: object
      required:
        - analysis_summary
        - rls_recommendations
        - hardcoded_secrets
        - backend_functions
        - open_backend_functions
        - unlocked_user_fields
        - exposed_fields
        - dependency_vulnerabilities
        - static_code_findings
        - header_recommendations
        - core_integration_recommendation
        - creator_email_exposure
        - ignored_fingerprints
        - scanned_at
      title: SecurityScanFindings
      description: What a completed security scan found.
    SecurityScanStreamProgress:
      properties:
        result:
          $ref: '#/components/schemas/SecurityScanFindings'
          description: >-
            What the areas that have already reported found, in the same shape
            as `result`. An area that has not reported yet contributes an empty
            list, which is not the same as a clean result, so read `sections`
            before concluding there is nothing to find.
        sections:
          additionalProperties:
            type: string
          type: object
          title: Sections
          description: >-
            How each area of the scan is doing, keyed by area: `rls`,
            `hardcoded_secrets`, `backend_functions`,
            `dependency_vulnerabilities` and `static_code`. `checking` means the
            area has not reported yet, `completed` means its findings are in
            this block's `result`, `failed` means it could not be checked, and
            `not_run` means it does not apply to this app. Only `completed`
            means the area's findings are settled.
          example:
            backend_functions: completed
            dependency_vulnerabilities: checking
            hardcoded_secrets: completed
            rls: completed
            static_code: not_run
      type: object
      required:
        - result
        - sections
      title: SecurityScanStreamProgress
      description: How far a still-running security scan has got, area by area.
    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
    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
    SecurityRlsRecommendation:
      properties:
        entity_name:
          type: string
          title: Entity Name
          description: >-
            Entity the recommendation is for, as returned by [List entity
            schemas](/api-reference/list-entity-schemas).
          example: Order
        description:
          type: string
          title: Description
          description: Why the scan recommends these rules, in plain language.
          example: >-
            Orders are readable by anyone. Restrict reads to the customer who
            placed the order.
        create_rule:
          anyOf:
            - additionalProperties: true
              type: object
            - type: boolean
            - type: 'null'
          title: Create Rule
          description: >-
            Recommended rule for creating a record. The rule to apply to this
            operation. `true` allows it for everyone, `false` blocks it
            outright, `null` leaves it unset, and an object is a filter matched
            against the record and the signed-in app user. Send the four rules
            to [Update entity schema](/api-reference/update-entity-schema) under
            the entity's `rls` to apply them.
          example:
            user_condition:
              id: '{{user.id}}'
        read_rule:
          anyOf:
            - additionalProperties: true
              type: object
            - type: boolean
            - type: 'null'
          title: Read Rule
          description: >-
            Recommended rule for reading records. The rule to apply to this
            operation. `true` allows it for everyone, `false` blocks it
            outright, `null` leaves it unset, and an object is a filter matched
            against the record and the signed-in app user. Send the four rules
            to [Update entity schema](/api-reference/update-entity-schema) under
            the entity's `rls` to apply them.
          example:
            user_condition:
              id: '{{user.id}}'
        update_rule:
          anyOf:
            - additionalProperties: true
              type: object
            - type: boolean
            - type: 'null'
          title: Update Rule
          description: >-
            Recommended rule for updating a record. The rule to apply to this
            operation. `true` allows it for everyone, `false` blocks it
            outright, `null` leaves it unset, and an object is a filter matched
            against the record and the signed-in app user. Send the four rules
            to [Update entity schema](/api-reference/update-entity-schema) under
            the entity's `rls` to apply them.
          example:
            user_condition:
              id: '{{user.id}}'
        delete_rule:
          anyOf:
            - additionalProperties: true
              type: object
            - type: boolean
            - type: 'null'
          title: Delete Rule
          description: >-
            Recommended rule for deleting a record. The rule to apply to this
            operation. `true` allows it for everyone, `false` blocks it
            outright, `null` leaves it unset, and an object is a filter matched
            against the record and the signed-in app user. Send the four rules
            to [Update entity schema](/api-reference/update-entity-schema) under
            the entity's `rls` to apply them.
          example: false
        fingerprint:
          type: string
          title: Fingerprint
          description: >-
            [Stable
            ID](/developers/references/apps-api/sections/security#findings-and-fingerprints)
            for this finding. Send it to [Ignore security
            finding](/api-reference/ignore-security-finding) to hide the finding
            across rescans. It changes when the entity's fields change, so an
            ignored recommendation comes back then.
          example: 3f9a1c0e8b7d4a6f2e5c9b1d0a8f7e6c5b4a3d2e1f0c9b8a7d6e5f4c3b2a1d0e
      type: object
      required:
        - entity_name
        - description
        - create_rule
        - read_rule
        - update_rule
        - delete_rule
        - fingerprint
      title: SecurityRlsRecommendation
      description: A recommended row-level security rule set for one entity.
    SecurityHardcodedSecret:
      properties:
        file_path:
          type: string
          title: File Path
          description: Path of the file in the app where it was found.
          example: src/pages/Checkout.jsx
        description:
          type: string
          title: Description
          description: >-
            What was found and why it is a problem. The secret's own value is
            not included.
          example: >-
            A Stripe live key is written into the checkout page. Move it to an
            app secret and read it from a backend function.
        fingerprint:
          type: string
          title: Fingerprint
          description: >-
            [Stable
            ID](/developers/references/apps-api/sections/security#findings-and-fingerprints)
            for this finding. Send it to [Ignore security
            finding](/api-reference/ignore-security-finding) to hide the finding
            across rescans. It changes when the file changes, so an ignored
            finding comes back once the file is edited.
          example: 3f9a1c0e8b7d4a6f2e5c9b1d0a8f7e6c5b4a3d2e1f0c9b8a7d6e5f4c3b2a1d0e
      type: object
      required:
        - file_path
        - description
        - fingerprint
      title: SecurityHardcodedSecret
      description: A credential written directly into the app's code.
    SecurityBackendFunctionIssue:
      properties:
        file_path:
          type: string
          title: File Path
          description: Path of the file in the app where it was found.
          example: functions/createOrder.js
        description:
          type: string
          title: Description
          description: What is wrong with the function and what to change.
          example: >-
            createOrder trusts the price sent by the browser. Look the price up
            server-side instead.
        fingerprint:
          type: string
          title: Fingerprint
          description: >-
            [Stable
            ID](/developers/references/apps-api/sections/security#findings-and-fingerprints)
            for this finding. Send it to [Ignore security
            finding](/api-reference/ignore-security-finding) to hide the finding
            across rescans. It changes when the function's file changes, so an
            ignored finding comes back once the file is edited.
          example: 3f9a1c0e8b7d4a6f2e5c9b1d0a8f7e6c5b4a3d2e1f0c9b8a7d6e5f4c3b2a1d0e
      type: object
      required:
        - file_path
        - description
        - fingerprint
      title: SecurityBackendFunctionIssue
      description: A problem found in one of the app's backend functions.
    SecurityOpenBackendFunction:
      properties:
        name:
          type: string
          title: Name
          description: Name of the backend function.
          example: sendInvite
        file_path:
          type: string
          title: File Path
          description: Path of the function's entry file in the app.
          example: base44/functions/sendInvite/entry.ts
        service_role:
          type: boolean
          title: Service Role
          description: >-
            Whether it uses the service role, which skips the app's data
            permissions.
          example: true
        writes_data:
          type: boolean
          title: Writes Data
          description: Whether it creates, updates, or deletes entity records.
          example: true
        sends_messages:
          type: boolean
          title: Sends Messages
          description: Whether it sends email or SMS.
          example: true
        uses_ai:
          type: boolean
          title: Uses Ai
          description: Whether it calls an AI integration, which uses the owner's credits.
          example: false
        calls_external:
          type: boolean
          title: Calls External
          description: Whether it calls an external URL.
          example: false
        secret_names:
          items:
            type: string
          type: array
          title: Secret Names
          description: Names of the app secrets it reads, never their values. At most 10.
          example:
            - RESEND_KEY
        has_caller_check:
          type: boolean
          title: Has Caller Check
          description: >-
            Whether it checks a key or signature the caller must present. Found
            in the code, not confirmed to work.
          example: false
        caller_count:
          type: integer
          title: Caller Count
          description: >-
            How many files in the app call it. Calls from outside the app's code
            are not counted.
          example: 1
        caller_paths:
          items:
            type: string
          type: array
          title: Caller Paths
          description: Up to 5 of those files.
          example:
            - src/pages/Invite.jsx
        severity:
          anyOf:
            - type: string
            - type: 'null'
          title: Severity
          description: >-
            `low`: every function is grouped as callable by anyone, by design,
            including ones the security review noted (see `findings`). `null` on
            a result recorded before Base44 stored it.
          example: low
        findings:
          anyOf:
            - items:
                type: string
              type: array
            - type: 'null'
          title: Findings
          description: >-
            What the security review noted about this function, if anything. An
            entry can also be server code that isn't a backend function, with
            its path as `name` and no signals.
        fingerprint:
          type: string
          title: Fingerprint
          description: >-
            [Stable
            ID](/developers/references/apps-api/sections/security#findings-and-fingerprints)
            for this finding. Send it to [Ignore security
            finding](/api-reference/ignore-security-finding) to hide the finding
            across rescans. It changes when any file in the function's folder
            changes, so an acknowledged function comes back once its code is
            edited.
          example: 3f9a1c0e8b7d4a6f2e5c9b1d0a8f7e6c5b4a3d2e1f0c9b8a7d6e5f4c3b2a1d0e
      type: object
      required:
        - name
        - file_path
        - service_role
        - writes_data
        - sends_messages
        - uses_ai
        - calls_external
        - secret_names
        - has_caller_check
        - caller_count
        - caller_paths
        - fingerprint
      title: SecurityOpenBackendFunction
      description: What one backend function can do, on an app that doesn't require login.
    SecurityUnlockedUserField:
      properties:
        field:
          type: string
          title: Field
          description: Name of the custom User field.
          example: tenant_id
        declared:
          type: boolean
          title: Declared
          description: Whether the app's User schema declares the field.
          example: true
        trusted_by:
          items:
            $ref: '#/components/schemas/SecurityUnlockedUserFieldUse'
          type: array
          title: Trusted By
          description: Every entity whose rules read the field.
        severity:
          type: string
          title: Severity
          description: >-
            `high` when anyone can sign up to the app, so anyone can set the
            field; `medium` otherwise.
          example: high
        fingerprint:
          type: string
          title: Fingerprint
          description: >-
            [Stable
            ID](/developers/references/apps-api/sections/security#findings-and-fingerprints)
            for this finding. Send it to [Ignore security
            finding](/api-reference/ignore-security-finding) to hide the finding
            across rescans. It changes when another entity's rules start reading
            the field, so an acknowledged field comes back.
          example: 3f9a1c0e8b7d4a6f2e5c9b1d0a8f7e6c5b4a3d2e1f0c9b8a7d6e5f4c3b2a1d0e
      type: object
      required:
        - field
        - declared
        - trusted_by
        - severity
        - fingerprint
      title: SecurityUnlockedUserField
      description: >-
        A custom User field that access rules trust but app users can change on
        their own record.
    SecurityExposedField:
      properties:
        entity:
          type: string
          title: Entity
          description: Entity whose records everyone can read.
          example: Testimonial
        field:
          type: string
          title: Field
          description: The field to hide with a field-level read rule.
          example: client_email
        reason:
          type: string
          title: Reason
          description: What private data the field holds.
          example: Private client email addresses
        category:
          anyOf:
            - type: string
            - type: 'null'
          title: Category
          description: >-
            What the field holds: `contact`, `credential_or_code`, `payment`,
            `health`, `id_document`, `location` or `private_note`. Absent on a
            finding recorded before Base44 asked.
          example: contact
        fingerprint:
          type: string
          title: Fingerprint
          description: >-
            [Stable
            ID](/developers/references/apps-api/sections/security#findings-and-fingerprints)
            for this finding. Send it to [Ignore security
            finding](/api-reference/ignore-security-finding) to hide the finding
            across rescans. It is keyed on the entity and field, so an
            acknowledged field stays acknowledged.
          example: 3f9a1c0e8b7d4a6f2e5c9b1d0a8f7e6c5b4a3d2e1f0c9b8a7d6e5f4c3b2a1d0e
      type: object
      required:
        - entity
        - field
        - reason
        - fingerprint
      title: SecurityExposedField
      description: >-
        A field on an entity everyone can read that holds data strangers should
        not see.
    SecurityDependencyVulnerability:
      properties:
        package_name:
          type: string
          title: Package Name
          description: Name of the npm package.
          example: axios
        current_version:
          type: string
          title: Current Version
          description: Version the app currently has.
          example: 1.6.2
        vulnerable_range:
          anyOf:
            - type: string
            - type: 'null'
          title: Vulnerable Range
          description: >-
            Range of versions the advisory covers, or `null` when the advisory
            does not give one.
          example: <1.7.4
        fixed_version:
          anyOf:
            - type: string
            - type: 'null'
          title: Fixed Version
          description: >-
            First version the advisory says is fixed, or `null` when there is no
            fixed release.
          example: 1.7.4
        safe_fixed_version:
          anyOf:
            - type: string
            - type: 'null'
          title: Safe Fixed Version
          description: >-
            The version Base44 checked is safe to install, which can be newer
            than `fixed_version`. It is `null` when no safe version was found,
            and absent on a finding recorded before Base44 started checking.
          example: 1.7.4
        fix_unavailable_reason:
          anyOf:
            - type: string
            - type: 'null'
          title: Fix Unavailable Reason
          description: >-
            Why no safe upgrade exists, when that is the case. It is `null` or
            absent when there is one.
          example: No released version satisfies the app's peer dependencies.
        vuln_id:
          type: string
          title: Vuln Id
          description: Advisory identifier.
          example: GHSA-8hc4-vh64-cxmj
        severity:
          type: string
          title: Severity
          description: How serious it is, one of `critical`, `high`, `medium` or `low`.
          example: high
        summary:
          type: string
          title: Summary
          description: One-line summary of the vulnerability.
          example: Server-side request forgery in axios
        advisory_url:
          type: string
          title: Advisory Url
          description: Link to the full advisory.
          example: https://github.com/advisories/GHSA-8hc4-vh64-cxmj
        fingerprint:
          type: string
          title: Fingerprint
          description: >-
            [Stable
            ID](/developers/references/apps-api/sections/security#findings-and-fingerprints)
            for this finding. Send it to [Ignore security
            finding](/api-reference/ignore-security-finding) to hide the finding
            across rescans. Every vulnerability in the same version of a package
            shares one fingerprint, so ignoring one ignores them all. It changes
            when the installed version changes or the package's advisories,
            their severities, or their fixed versions change, so an ignored
            package comes back then.
          example: 3f9a1c0e8b7d4a6f2e5c9b1d0a8f7e6c5b4a3d2e1f0c9b8a7d6e5f4c3b2a1d0e
      type: object
      required:
        - package_name
        - current_version
        - vulnerable_range
        - fixed_version
        - vuln_id
        - severity
        - summary
        - advisory_url
        - fingerprint
      title: SecurityDependencyVulnerability
      description: A known vulnerability in one of the app's npm dependencies.
    SecurityStaticCodeFinding:
      properties:
        title:
          type: string
          title: Title
          description: Short name for the problem.
          example: Order lookup trusts a client-supplied ID
        severity:
          type: string
          title: Severity
          description: How serious it is, one of `critical`, `high`, `medium` or `low`.
          example: high
        confidence:
          type: string
          title: Confidence
          description: >-
            How sure the scan is, one of `high`, `medium` or `low`. A `low`
            confidence finding is worth reading before acting on.
          example: high
        category:
          type: string
          title: Category
          description: >-
            What kind of problem it is, one of `unauthorized_access`,
            `unsafe_user_input`, `exposed_sensitive_data`,
            `unsafe_redirect_or_external_request`, `unsafe_browser_code`,
            `payment_or_webhook_risk`, `file_handling_risk`, `ai_vulnerability`
            or `other`.
          example: unauthorized_access
        file_path:
          type: string
          title: File Path
          description: Path of the file in the app where it was found.
          example: src/pages/Orders.jsx
        line_number:
          anyOf:
            - type: integer
            - type: 'null'
          title: Line Number
          description: >-
            Line the finding points at, or `null` when the scan could not place
            it on one.
          example: 42
        evidence:
          type: string
          title: Evidence
          description: The snippet of the app's own code the finding is about.
          example: const order = await Order.get(searchParams.get('id'))
        attack_scenario:
          type: string
          title: Attack Scenario
          description: How someone would exploit it.
          example: Change the id in the URL to another customer's order and read it.
        impact:
          type: string
          title: Impact
          description: What it costs if exploited.
          example: Any signed-in user can read every order.
        recommendation:
          type: string
          title: Recommendation
          description: What to change.
          example: >-
            Add a read rule on Order restricting it to the customer who placed
            it.
        standards:
          anyOf:
            - items:
                $ref: '#/components/schemas/SecurityStaticCodeStandard'
              type: array
            - type: 'null'
          title: Standards
          description: >-
            Security standards the finding maps to. Absent on a finding the scan
            did not classify.
          example:
            - framework: CWE
              id: CWE-639
              name: Authorization Bypass Through User-Controlled Key
        fingerprint:
          type: string
          title: Fingerprint
          description: >-
            [Stable
            ID](/developers/references/apps-api/sections/security#findings-and-fingerprints)
            for this finding. Send it to [Ignore security
            finding](/api-reference/ignore-security-finding) to hide the finding
            across rescans. It stays the same when only the wording or line
            number changes, and changes when the file, `category`, or `evidence`
            does, so an ignored finding comes back then.
          example: 3f9a1c0e8b7d4a6f2e5c9b1d0a8f7e6c5b4a3d2e1f0c9b8a7d6e5f4c3b2a1d0e
      type: object
      required:
        - title
        - severity
        - confidence
        - category
        - file_path
        - line_number
        - evidence
        - attack_scenario
        - impact
        - recommendation
        - fingerprint
      title: SecurityStaticCodeFinding
      description: A problem found by reading the app's code.
    SecurityHeaderRecommendation:
      properties:
        flag:
          type: string
          title: Flag
          description: >-
            Which setting to turn on, either `prevent_iframe_embedding` or
            `restrict_browser_features`. Turn it on with [Update security
            headers](/api-reference/update-security-headers), or hide the
            recommendation with [Dismiss header
            recommendation](/api-reference/dismiss-header-recommendation).
          example: prevent_iframe_embedding
        severity:
          type: string
          title: Severity
          description: How serious it is, one of `high`, `medium` or `low`.
          example: medium
        reason_key:
          type: string
          title: Reason Key
          description: >-
            Stable identifier for the reason. The readable text is Base44's own
            translated copy, so treat this as a code to branch on rather than
            something to show.
          example: security.headers.reason.iframe_embedding
      type: object
      required:
        - flag
        - severity
        - reason_key
      title: SecurityHeaderRecommendation
      description: A recommended change to the published app's HTTP headers.
    SecurityCreatorEmailExposure:
      properties:
        state:
          type: string
          title: State
          description: >-
            `needs_code_fix` means the app's code reads `created_by` (listed in
            `reads`) and has to move to `created_by_id` or its own owner field
            first. `publish_required` means the editor code is ready but the
            published version still reads it. `can_enable` means turning on
            `hide_entity_created_by` with [Update
            app](/api-reference/update-app) won't break the app.
          example: can_enable
        severity:
          type: string
          title: Severity
          description: '`high` when the app doesn''t require login, else `medium`.'
          example: medium
        reads:
          items:
            $ref: '#/components/schemas/SecurityCreatorEmailRead'
          type: array
          title: Reads
          description: Where the code reads `created_by`, up to 50.
          example: []
      type: object
      required:
        - state
        - severity
        - reads
      title: SecurityCreatorEmailExposure
    SecurityUnlockedUserFieldUse:
      properties:
        entity:
          type: string
          title: Entity
          description: Entity whose rules read the field.
          example: Invoice
        uses:
          items:
            type: string
          type: array
          title: Uses
          description: >-
            The operations whose rule reads it, or `field:<name>` for a
            field-level rule on that entity.
          example:
            - read
            - update
      type: object
      required:
        - entity
        - uses
      title: SecurityUnlockedUserFieldUse
      description: One entity whose access rules read the field.
    SecurityStaticCodeStandard:
      properties:
        framework:
          type: string
          title: Framework
          description: Which catalog the identifier belongs to.
          example: CWE
        id:
          type: string
          title: Id
          description: Identifier within that catalog.
          example: CWE-639
        name:
          type: string
          title: Name
          description: Name of the entry.
          example: Authorization Bypass Through User-Controlled Key
      type: object
      required:
        - framework
        - id
        - name
      title: SecurityStaticCodeStandard
      description: A security standard a static-analysis finding maps to.
    SecurityCreatorEmailRead:
      properties:
        file_path:
          type: string
          title: File Path
          description: File that reads `created_by` off a record.
          example: src/pages/Tasks.jsx
        line:
          type: integer
          title: Line
          description: Line of the read, starting at 1.
          example: 42
      type: object
      required:
        - file_path
        - line
      title: SecurityCreatorEmailRead
  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.