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

# Preview JSON-LD

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

Returns the Schema.org markup Base44 generates from the app's entities, so you can see it before publishing it.

Base44 matches each entity to the Schema.org type its fields look most like, and leaves out any entity it can't match with reasonable confidence, so an app whose entities are all app-specific returns an empty list.

Each entry's `json_ld_template` marks which entity field fills each property using a placeholder. For example, `{"name": "{title}"}` means `name` comes from this entity's `title` field.

There's no mechanism that fills in a placeholder for you. To use a field, edit `json_ld_template` yourself before saving it with [Update SEO settings](/api-reference/update-seo-settings), replacing `{title}` with an actual value, for example `{"name": "Acme CRM"}` instead of `{"name": "{title}"}`. Base44 injects whatever you save exactly as written, on every page the entry applies to. There's no per-record substitution, so a hardcoded value shows up identically everywhere rather than varying by record.

Save the whole entry, including its `json_ld_template` key, as one of the objects in `custom_json_ld` with [Update SEO settings](/api-reference/update-seo-settings). Saving alone isn't enough for the markup to appear on the page. See [When JSON-LD markup goes live](/developers/references/apps-api/sections/seo#when-json-ld-markup-goes-live) for what else has to be true.

Save `confidence` as a string, or leave it out.
<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}/seo/preview/json-ld
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}/seo/preview/json-ld:
    get:
      summary: Preview JSON-LD
      description: >-
        <Info>This API is in beta. Endpoints, fields, and behavior may still
        change, so avoid depending on it in production.</Info>


        Returns the Schema.org markup Base44 generates from the app's entities,
        so you can see it before publishing it.


        Base44 matches each entity to the Schema.org type its fields look most
        like, and leaves out any entity it can't match with reasonable
        confidence, so an app whose entities are all app-specific returns an
        empty list.


        Each entry's `json_ld_template` marks which entity field fills each
        property using a placeholder. For example, `{"name": "{title}"}` means
        `name` comes from this entity's `title` field.


        There's no mechanism that fills in a placeholder for you. To use a
        field, edit `json_ld_template` yourself before saving it with [Update
        SEO settings](/api-reference/update-seo-settings), replacing `{title}`
        with an actual value, for example `{"name": "Acme CRM"}` instead of
        `{"name": "{title}"}`. Base44 injects whatever you save exactly as
        written, on every page the entry applies to. There's no per-record
        substitution, so a hardcoded value shows up identically everywhere
        rather than varying by record.


        Save the whole entry, including its `json_ld_template` key, as one of
        the objects in `custom_json_ld` with [Update SEO
        settings](/api-reference/update-seo-settings). Saving alone isn't enough
        for the markup to appear on the page. See [When JSON-LD markup goes
        live](/developers/references/apps-api/sections/seo#when-json-ld-markup-goes-live)
        for what else has to be true.


        Save `confidence` as a string, or leave it out.

        <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: preview_json_ld_api_apps__app_id__seo_preview_json_ld_get
      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
      responses:
        '200':
          description: The generated Schema.org markup.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/JsonLdPreviewResponse'
        '401':
          description: Missing or invalid credentials.
        '403':
          description: >-
            You don't have access to this app. These endpoints accept a personal
            access token or a workspace API key, including a read-only one.
        '404':
          description: App not found.
        '429':
          description: >-
            Rate limit exceeded. The base limit is 30 requests per minute for
            each app, counted across the workspace rather than per caller, and
            shared with the app's other SEO endpoints. 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:
            - read_only
        - WorkspaceApiKeyAuth:
            - read_only
        - WorkspaceApiKeyBearerAuth:
            - read_only
components:
  schemas:
    JsonLdPreviewResponse:
      properties:
        result:
          $ref: '#/components/schemas/JsonLdPreview'
          description: The generated markup.
      type: object
      required:
        - result
      title: JsonLdPreviewResponse
      description: The preview.
    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.
    JsonLdPreview:
      properties:
        entities:
          items:
            $ref: '#/components/schemas/JsonLdEntity'
          type: array
          title: Entities
          description: >-
            One entry per entity Base44 could match to a Schema.org type. Empty
            when none of the app's entities match one confidently.
          example:
            - confidence: 0.85
              entity_name: Product
              field_mapping:
                name: title
              json_ld_template:
                '@context': https://schema.org
                '@type': Product
                name: '{title}'
              schema_type: Product
      type: object
      title: JsonLdPreview
      description: The Schema.org markup Base44 would publish for this app.
    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
    JsonLdEntity:
      properties:
        entity_name:
          type: string
          title: Entity Name
          description: Name of the app entity this markup describes.
          example: Product
        schema_type:
          type: string
          title: Schema Type
          description: The Schema.org type Base44 matched the entity to.
          example: Product
        confidence:
          type: number
          title: Confidence
          description: >-
            How sure the match is, 0 to 1. Base44 leaves out any entity below
            0.2.
          example: 0.85
        json_ld_template:
          additionalProperties: true
          type: object
          title: Json Ld Template
          description: >-
            The JSON-LD Base44 would inject, with `{field}` placeholders naming
            the entity fields that fill it. Written verbatim into the page, so
            the placeholders are not substituted per record.
          example:
            '@context': https://schema.org
            '@type': Product
            description: '{summary}'
            name: '{title}'
        field_mapping:
          additionalProperties: true
          type: object
          title: Field Mapping
          description: >-
            Which entity field fills each Schema.org property, keyed by
            property.
          example:
            description: summary
            name: title
      type: object
      required:
        - entity_name
        - schema_type
        - confidence
        - json_ld_template
        - field_mapping
      title: JsonLdEntity
      description: One entity Base44 can describe with Schema.org markup.
  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.