> ## Documentation Index
> Fetch the complete documentation index at: https://docs.querying.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Verificar la integración de un sitio

> Demuestra que el CDN del sitio entrega a los agentes la copia de una página.



## OpenAPI

````yaml POST /v1/ai-rendering/sites/{id}/verifications
openapi: 3.1.0
info:
  title: querying.ai
  description: >-
    One API for every AI answer engine. Every task is asynchronous: submit, then
    collect the result via webhook or polling.
  version: 1.0.0
servers:
  - url: https://api.querying.ai
    description: Production
security:
  - bearerAuth: []
paths:
  /v1/ai-rendering/sites/{id}/verifications:
    parameters:
      - name: id
        in: path
        required: true
        description: The site's id.
        schema:
          type: string
    post:
      tags:
        - AI Rendering
      summary: Verify a site's integration
      description: >-
        Proves that the site's CDN gives agents the copy of one page. It first
        requests the page from the site twice, as ChatGPT-User and as a visitor,
        and reports what each got in edge. Then it asks ChatGPT about the page
        under an address ChatGPT has not opened before, as a CHATGPT task of the
        account at that task's price, and matches the request ChatGPT makes for
        that address in visit. Poll GET
        /v1/ai-rendering/sites/{id}/verifications/{verificationId} until stage
        is completed or failed; it takes about a minute. Requests for a
        verification's address are served the page's copy, and our own request
        as an agent is left out of the site's activity.
      operationId: createAiRenderingVerification
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/AiRenderingVerificationRequest'
            example:
              url: https://www.example.com/products/down-jacket
              questions:
                - What is the fill power of the jacket?
      responses:
        '201':
          description: 'Complete: chatgpt was false, so only the edge was read.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AiRenderingVerificationResponse'
              example:
                success: true
                verification:
                  id: 7d0f6a1e-93b2-4f0b-8f6e-5a2c1d9e4b70
                  siteId: 5b0e9f52-6a3c-4f0e-8d0b-2c7e4a1f9d33
                  url: https://www.example.com/products/down-jacket
                  stage: completed
                  verified: true
                  createdAt: '2026-11-15T01:00:00.000Z'
                  completedAt: '2026-11-15T01:00:00.000Z'
                  edge:
                    agent:
                      status: 200
                      rendering: HIT
                      renderedAt: '2026-11-14T09:30:00.000Z'
                      error: null
                    visitor:
                      status: 200
                      rendering: MISS
                      renderedAt: null
                      error: null
                    problem: null
                  visit: null
                  creditsCharged: 0
                  chatgpt: null
        '202':
          description: The edge was read and ChatGPT is being asked.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AiRenderingVerificationResponse'
              example:
                success: true
                verification:
                  id: 7d0f6a1e-93b2-4f0b-8f6e-5a2c1d9e4b70
                  siteId: 5b0e9f52-6a3c-4f0e-8d0b-2c7e4a1f9d33
                  url: https://www.example.com/products/down-jacket
                  stage: asking_chatgpt
                  verified: true
                  createdAt: '2026-11-15T01:00:00.000Z'
                  completedAt: null
                  edge:
                    agent:
                      status: 200
                      rendering: HIT
                      renderedAt: '2026-11-14T09:30:00.000Z'
                      error: null
                    visitor:
                      status: 200
                      rendering: MISS
                      renderedAt: null
                      error: null
                    problem: null
                  chatgpt:
                    taskId: 0b6c1f7e-2d4a-4c55-9a0e-3f1d2b7c8e91
                    askedUrl: >-
                      https://www.example.com/products/down-jacket?utm_id=qv7d0f6a1e93b24f0b8f6e5a2c1d9e4b70
                    questions:
                      - What is the fill power of the jacket?
                    answer: null
                  visit: null
                  creditsCharged: 0
        '400':
          description: >-
            VALIDATION_ERROR: the body is not a JSON object or has a field other
            than url, questions and chatgpt.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '401':
          description: Missing or invalid API key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '402':
          description: 'INSUFFICIENT_CREDITS: the balance cannot cover the CHATGPT task.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '404':
          description: >-
            NOT_FOUND: no site of the account with that id, or the site has not
            published that page.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '409':
          description: 'PAGE_NOT_READY: the page has no copy to serve yet.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '422':
          description: >-
            VALIDATION_ERROR: url is not a page of the site, questions is not a
            list of 1 to 6 texts of up to 300 characters, or chatgpt is not a
            boolean.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '429':
          description: The account's rate or concurrency limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
components:
  schemas:
    AiRenderingVerificationRequest:
      type: object
      required:
        - url
      properties:
        url:
          type: string
          description: A page of the site whose copy is ready.
        questions:
          type: array
          minItems: 1
          maxItems: 6
          items:
            type: string
            maxLength: 300
          description: >-
            The questions ChatGPT is asked about the page. Without them it is
            asked what the page is about and which facts it states. The
            questions of a check make the answers comparable with the check's.
        chatgpt:
          type: boolean
          default: true
          description: >-
            false reads the site's edge only: nothing is asked, nothing is
            charged, and the verification is complete in the response.
    AiRenderingVerificationResponse:
      type: object
      required:
        - success
        - verification
      properties:
        success:
          type: boolean
        verification:
          $ref: '#/components/schemas/AiRenderingVerification'
    ErrorResponse:
      type: object
      required:
        - success
        - error
      properties:
        success:
          type: boolean
          const: false
        error:
          $ref: '#/components/schemas/ErrorDetail'
    AiRenderingVerification:
      type: object
      required:
        - id
        - siteId
        - url
        - stage
        - verified
        - createdAt
        - completedAt
        - edge
        - visit
        - creditsCharged
      properties:
        id:
          type: string
        siteId:
          type: string
        url:
          type: string
          description: The page, without tracking parameters.
        stage:
          type: string
          enum:
            - asking_chatgpt
            - completed
            - failed
          description: >-
            failed when ChatGPT gave no answer; edge and visit still say what
            was seen.
        verified:
          type: boolean
          description: >-
            The copy reached an agent: our own request as ChatGPT-User got it,
            or the visit ChatGPT made did. false while people get the copy too.
        createdAt:
          type: string
          format: date-time
        completedAt:
          type:
            - string
            - 'null'
          format: date-time
        edge:
          type: object
          required:
            - agent
            - visitor
            - problem
          description: >-
            What the site's CDN answered two requests for the page from our
            servers.
          properties:
            agent:
              type: object
              required:
                - status
                - rendering
                - renderedAt
                - error
              description: >-
                The request with ChatGPT-User's User-Agent. A working
                integration answers it with the copy.
              properties:
                status:
                  type:
                    - integer
                    - 'null'
                  description: >-
                    The HTTP status the site answered; null when it gave no
                    answer.
                rendering:
                  type: string
                  enum:
                    - HIT
                    - MISS
                  description: 'HIT when the answer carried X-Querying-Rendering: HIT.'
                renderedAt:
                  type:
                    - string
                    - 'null'
                  description: The copy's X-Querying-Rendered-At, on a HIT.
                error:
                  type:
                    - string
                    - 'null'
                  description: Why the site gave no answer.
            visitor:
              type: object
              required:
                - status
                - rendering
                - renderedAt
                - error
              description: >-
                The request with a User-Agent that is no AI agent's. A working
                integration answers it with the site's own page.
              properties:
                status:
                  type:
                    - integer
                    - 'null'
                  description: >-
                    The HTTP status the site answered; null when it gave no
                    answer.
                rendering:
                  type: string
                  enum:
                    - HIT
                    - MISS
                  description: 'HIT when the answer carried X-Querying-Rendering: HIT.'
                renderedAt:
                  type:
                    - string
                    - 'null'
                  description: The copy's X-Querying-Rendered-At, on a HIT.
                error:
                  type:
                    - string
                    - 'null'
                  description: Why the site gave no answer.
            problem:
              type:
                - string
                - 'null'
              enum:
                - not_serving
                - agent_blocked
                - unreachable
                - served_to_visitors
                - null
              description: >-
                null when the agent got the copy and the visitor did not.
                not_serving: the site answered without the copy, so the
                integration is not installed on this path, holds another site's
                key, or runs on Edge Sync before its first sync. agent_blocked:
                the site refused the agent's User-Agent from our address and
                answered the visitor, as a firewall that checks an agent's
                address does; the visit ChatGPT makes decides. unreachable: the
                site gave no answer or refused both requests.
                served_to_visitors: people get the copy too, which the
                integration must never do.
        chatgpt:
          type:
            - object
            - 'null'
          required:
            - taskId
            - askedUrl
            - questions
            - answer
          description: >-
            The question ChatGPT was asked; null with chatgpt: false. Left out
            of the list.
          properties:
            taskId:
              type: string
              description: >-
                The CHATGPT task that asks. GET /v1/async/task/{taskId} has its
                sources.
            askedUrl:
              type: string
              description: >-
                The address ChatGPT was given: the page with a utm_id that names
                this verification, so ChatGPT opens it afresh.
            questions:
              type: array
              items:
                type: string
            answer:
              type:
                - string
                - 'null'
              description: ChatGPT's reply; null until it answers.
            error:
              type: string
              description: Why ChatGPT gave no answer, when stage is failed.
        visit:
          type:
            - object
            - 'null'
          required:
            - at
            - agent
            - result
            - reason
          description: >-
            The request an agent made for askedUrl, as Edge Serve answered it;
            null until one arrives. A site on Edge Sync answers from its own
            CDN, so its visits are not seen here and edge is its proof.
          properties:
            at:
              type: string
              format: date-time
            agent:
              type: string
            result:
              type: string
              enum:
                - HIT
                - MISS
            reason:
              type:
                - string
                - 'null'
              description: The MISS reason.
        creditsCharged:
          type: number
          description: >-
            What the CHATGPT task was charged; 0 until it ends and with chatgpt:
            false.
    ErrorDetail:
      type: object
      required:
        - code
        - message
      properties:
        code:
          type: string
          description: Stable, safe to branch on. See the Errors guide for the full list.
        message:
          type: string
          description: For humans. May change.
        details:
          description: >-
            Context for the error. An array of `{field, message}` on most
            `VALIDATION_ERROR`s; an object elsewhere (for example `{id}` on
            `RESOURCE_NOT_FOUND`, `retryAfterSec` on 429 and 503 codes). Omitted
            when there is nothing to add.
          oneOf:
            - type: array
              items:
                type: object
                properties:
                  field:
                    type: string
                  message:
                    type: string
            - type: object
              additionalProperties: true
        timestamp:
          type: string
          format: date-time
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: 'Your API key, sent as `Authorization: Bearer <key>`.'

````

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