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

# Scan Google Ads conversion tracking

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

Cross-references the app's conversion mappings against the conversion calls in its code, and reports what does not line up.

Each entry in `gaps` names one problem. An `error` is a mapped conversion that cannot fire, and a `warning` is a setup that works but probably is not what you meant, such as a disabled mapping or code firing a goal no mapping points at. A `missing-call-` gap also carries a `composer_prompt` you can hand to [Send chat message](/api-reference/send-chat-message) to have the AI write the fix.

<Warning>Treat `error` gaps and `calls_count` as unverified. The scan reads the app's code from a copy that is empty for apps built in the current editor, so it reports `calls_count` as `0` and raises a `missing-call-` gap for every enabled mapping even when the call is present and working. Base44's own alerting re-checks these against the deployed app before acting on them, and this endpoint does not. Confirm a `missing-call-` gap against the app's real code before changing anything, and do not read `calls_count` as evidence that no conversions fire.</Warning>

<Warning>`is_clean` is `true` when nothing was scanned, so read `skipped_reason` first. An app with no Google Ads account comes back with `is_clean` set to `true`, no `gaps`, and `skipped_reason` set to `no_google_ads_account`, which is not a clean bill of health. That response also omits `enabled_mappings_count`.</Warning>

<Note>This endpoint accepts a personal API key. Workspace API keys are not authorized for it and are rejected with a 403.</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}/google-ads/tracking-scan
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}/google-ads/tracking-scan:
    get:
      summary: Scan Google Ads conversion tracking
      description: >-
        <Info>This API is in beta. Endpoints, fields, and behavior may still
        change, so avoid depending on it in production.</Info>


        Cross-references the app's conversion mappings against the conversion
        calls in its code, and reports what does not line up.


        Each entry in `gaps` names one problem. An `error` is a mapped
        conversion that cannot fire, and a `warning` is a setup that works but
        probably is not what you meant, such as a disabled mapping or code
        firing a goal no mapping points at. A `missing-call-` gap also carries a
        `composer_prompt` you can hand to [Send chat
        message](/api-reference/send-chat-message) to have the AI write the fix.


        <Warning>Treat `error` gaps and `calls_count` as unverified. The scan
        reads the app's code from a copy that is empty for apps built in the
        current editor, so it reports `calls_count` as `0` and raises a
        `missing-call-` gap for every enabled mapping even when the call is
        present and working. Base44's own alerting re-checks these against the
        deployed app before acting on them, and this endpoint does not. Confirm
        a `missing-call-` gap against the app's real code before changing
        anything, and do not read `calls_count` as evidence that no conversions
        fire.</Warning>


        <Warning>`is_clean` is `true` when nothing was scanned, so read
        `skipped_reason` first. An app with no Google Ads account comes back
        with `is_clean` set to `true`, no `gaps`, and `skipped_reason` set to
        `no_google_ads_account`, which is not a clean bill of health. That
        response also omits `enabled_mappings_count`.</Warning>


        <Note>This endpoint accepts a personal API key. Workspace API keys are
        not authorized for it and are rejected with a 403.</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: scan_tracking_api_apps__app_id__google_ads_tracking_scan_get
      parameters:
        - name: app_id
          in: path
          required: true
          schema:
            type: string
            description: >-
              ID of the app whose Google Ads conversion tracking you want to
              manage.
            title: App Id
          description: >-
            ID of the app whose Google Ads conversion tracking you want to
            manage.
          example: 6820f3a4e7b91d003c45a1f2
      responses:
        '200':
          description: What the scan found.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TrackingScanResult'
        '401':
          description: Missing or invalid credentials.
        '403':
          description: >-
            You don't have access to this app, the app does not exist, or you
            used a workspace API key. A missing app and an app you cannot reach
            are deliberately the same answer.
components:
  schemas:
    TrackingScanResult:
      properties:
        gaps:
          items:
            $ref: '#/components/schemas/TrackingGap'
          type: array
          title: Gaps
          description: >-
            Everything the scan flagged. Empty when it found nothing and when it
            did not run, which `skipped_reason` tells apart.
          example: []
        mappings_count:
          type: integer
          title: Mappings Count
          description: How many conversion mappings the account has, enabled or not.
          example: 3
        calls_count:
          type: integer
          title: Calls Count
          description: >-
            How many gtag conversion calls the scan found in the app's code. See
            the warning on this operation before reading it as zero.
          example: 0
        is_clean:
          type: boolean
          title: Is Clean
          description: >-
            Whether the scan flagged no error-severity gap (`true`) or at least
            one (`false`). It also reads `true` when the scan did not run at
            all, so check `skipped_reason` first.
          example: false
        enabled_mappings_count:
          anyOf:
            - type: integer
            - type: 'null'
          title: Enabled Mappings Count
          description: >-
            How many of the mappings are enabled. Absent when `skipped_reason`
            is set.
          example: 2
        skipped_reason:
          anyOf:
            - type: string
            - type: 'null'
          title: Skipped Reason
          description: >-
            Why nothing was scanned. The value is `no_google_ads_account` when
            the app has no active Google Ads account, or `app_not_found`. The
            field is absent whenever a scan ran.
          example: no_google_ads_account
      type: object
      required:
        - gaps
        - mappings_count
        - calls_count
        - is_clean
      title: TrackingScanResult
      description: What the conversion-tracking scan found.
    TrackingGap:
      properties:
        id:
          type: string
          title: Id
          description: >-
            Identifier for this gap within the scan. A gap whose ID starts with
            `missing-call-` is a mapped goal with no firing code, `no-action-`
            is a mapping with no matching goal in Google Ads, `disabled-` is a
            disabled mapping, and `orphan-call-` is code firing a conversion no
            mapping points at.
          example: missing-call-68b1c0d4e7b91d003c45a1f7
        severity:
          type: string
          title: Severity
          description: >-
            How serious the gap is. `error` means a mapped conversion cannot
            fire, and `warning` means the setup works but something is
            configured in a way you probably did not intend.
          example: error
        message:
          type: string
          title: Message
          description: >-
            What is wrong, written for an engineer. It names the `send_to` and
            the call shape where those apply.
          example: >-
            Order.create is mapped to PURCHASE but no gtag('event',
            'conversion', { send_to: 'AW-123456789/AbCdEfGhIj', ... }) call
            exists in the app code.
        suggested_files:
          items:
            type: string
          type: array
          title: Suggested Files
          description: >-
            Up to three files in the app that look like the place to add or fix
            the call. Empty when the scan has no suggestion.
          example:
            - src/pages/Checkout.jsx
        composer_prompt:
          type: string
          title: Composer Prompt
          description: >-
            An instruction you can send to [Send chat
            message](/api-reference/send-chat-message) to have the AI fix this
            gap. Only a `missing-call-` gap carries one; it is an empty string
            on every other kind.
          example: Add a Google Ads conversion call to the order confirmation flow.
        mapping_id:
          anyOf:
            - type: string
            - type: 'null'
          title: Mapping Id
          description: >-
            The conversion mapping this gap is about. Absent on an
            `orphan-call-` gap, which is about code rather than a mapping.
          example: 68b1c0d4e7b91d003c45a1f7
        conversion_type:
          anyOf:
            - type: string
            - type: 'null'
          title: Conversion Type
          description: >-
            Conversion category the mapping names, such as `PURCHASE`. Absent on
            an `orphan-call-` gap.
          example: PURCHASE
        entity_name:
          anyOf:
            - type: string
            - type: 'null'
          title: Entity Name
          description: >-
            App entity the mapping is tied to. Absent on a `disabled-` or
            `orphan-call-` gap, and empty on a mapping with no entity.
          example: Order
        trigger_action:
          anyOf:
            - type: string
            - type: 'null'
          title: Trigger Action
          description: >-
            Which write on the entity the mapping covers. Absent on a
            `disabled-` or `orphan-call-` gap.
          example: create
        send_to:
          anyOf:
            - type: string
            - type: 'null'
          title: Send To
          description: >-
            The gtag `send_to` value the code should fire. Present only on a
            `missing-call-` gap, which is the only kind that has resolved one.
          example: AW-123456789/AbCdEfGhIj
        display_message:
          anyOf:
            - type: string
            - type: 'null'
          title: Display Message
          description: >-
            The same problem in plain language, safe to show someone. Present
            only on a `missing-call-` gap.
          example: >-
            Your Purchase conversion is not being recorded when an order is
            created.
      type: object
      required:
        - id
        - severity
        - message
        - suggested_files
        - composer_prompt
      title: TrackingGap
      description: One problem the tracking scan found.
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: api_key
      description: Personal API key.

````