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

# GetPageContentReviewAPI mirrors erdo_get_page_content_review.




## OpenAPI

````yaml /api/openapi.json get /v1/pages/review/{pageID}
openapi: 3.0.0
info:
  title: Erdo API
  description: >-
    Erdo's REST API: query and write datasets, run agents, manage threads,
    integrations, pages, evals, workstreams, experiments, and bounded outreach.
    Authenticate with a Bearer API key (erdo_api_...) or scoped token
    (erdo_token_...).
  version: '2026-11-21'
servers:
  - url: https://api.erdo.ai
    description: Production
security:
  - bearerAuth: []
paths:
  /v1/pages/review/{pageID}:
    get:
      summary: |
        GetPageContentReviewAPI mirrors erdo_get_page_content_review.
      operationId: GET:mcp.GetPageContentReviewAPI
      parameters:
        - allowEmptyValue: true
          explode: false
          in: path
          name: pageID
          required: true
          schema:
            type: string
          style: simple
        - allowEmptyValue: true
          explode: true
          in: query
          name: review_id
          required: false
          schema:
            type: string
          style: form
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/agent.RequestedPageReview'
          description: Success response
        default:
          $ref: '#/components/responses/APIError'
components:
  schemas:
    agent.RequestedPageReview:
      properties:
        completed_at:
          format: date-time
          type: string
        created_at:
          format: date-time
          type: string
        error:
          type: string
        id:
          format: uuid
          type: string
        page_id:
          format: uuid
          type: string
        result:
          $ref: '#/components/schemas/agents.AgentArtifactReview'
        status:
          type: string
          enum:
            - running
            - ready
            - failed
      title: >
        RequestedPageReview is a durable invocation, separate from automatic
        content

        deduplication.
      type: object
      required:
        - id
        - page_id
        - status
        - created_at
    agents.AgentArtifactReview:
      description: >
        request\_review. Structured rather than prose so the tool result can
        carry it without a second formatting layer inventing its own vocabulary.
      properties:
        issues:
          items:
            $ref: '#/components/schemas/agents.ArtifactCriticIssue'
          type: array
        judges:
          items:
            type: string
          type: array
        lighthouse:
          $ref: '#/components/schemas/types.PageReviewLighthouse'
        reason:
          type: string
        reviewed:
          type: boolean
        summary:
          type: string
      title: >
        AgentArtifactReview is what an agent gets back when it asks for a review
        with
      type: object
    agents.ArtifactCriticIssue:
      properties:
        category:
          title: >
            brand | technical | conversion | copy | responsive | accessibility |
            compliance
          type: string
        description:
          title: |
            what's wrong, quoting the offending markup
          type: string
        id:
          title: |
            e.g. "brand-1", "technical-2"
          type: string
        judge_slug:
          description: >
            flat merged result fans back into per-judge verdicts
            (SplitCriticResultByJudge). Empty on the single-rubric path, where
            the call itself IS one judge.
          title: >
            JudgeSlug tags a MERGED-mode issue with the rubric it was raised
            against, so a
          type: string
        owner:
          title: |
            page | outside_page; missing/unknown keeps page ownership
          type: string
        repair_target:
          title: |
            what must change and where
          type: string
        severity:
          title: |
            low | medium | high | critical
          type: string
        suggestion:
          title: |
            the concrete change to make
          type: string
      title: |
        ArtifactCriticIssue is one problem found while reviewing the page.
      type: object
    types.PageReviewLighthouse:
      description: >
        the PageSpeed Insights API on the mobile strategy. Each is 0..100
        (Lighthouse's own 0..1 category score ×100, rounded). Optional by
        design: absent when PSI is unavailable, rate-limited, or times out — a
        missing Lighthouse never fails the review. FetchedAt stamps when the
        measurement was taken. Each category is a POINTER because Lighthouse
        itself reports null for a category whose lab run failed (observed live:
        performance=null on a page the other three categories scored fine) — a
        non-pointer int rendered that null as a fake catastrophic 0. An absent
        category is absent, never zero.
      properties:
        accessibility:
          format: int64
          type: integer
        best_practices:
          format: int64
          type: integer
        fetched_at:
          format: date-time
          type: string
        performance:
          format: int64
          type: integer
        performance_opportunities:
          description: >
            with positive savings, from categories.performance.auditRefs joined
            with audits. Titles, display values and savings are Lighthouse's own
            evidence; the category score above stays Google's number. Metric
            audits are excluded.
          items:
            $ref: '#/components/schemas/types.PageReviewPerformanceAudit'
          title: >
            PerformanceOpportunities carries up to five scored performance
            audits
          type: array
        seo:
          format: int64
          type: integer
        seo_audits:
          description: >
            the PSI response (categories.seo.auditRefs joined with audits):
            Lighthouse's category weight and the audit's 0..100 score, nil when
            Lighthouse did not score it (manual, informative, notApplicable,
            errored). The raw seo category score above stays Google's own
            number; this composition is what lets a grader separate a
            deliberate, policy-owned audit failure (the capture document's
            noindex is-crawlable) from page-owned SEO failures without
            re-deriving Lighthouse's scoring. Absent when PSI did not report the
            composition — an older or drifted shape is unknown, never a page
            defect.
          items:
            $ref: '#/components/schemas/types.PageReviewSEOAudit'
          title: >
            SEOAudits carries the SEO category's own audit composition, verbatim
            from
          type: array
      title: >
        PageReviewLighthouse is the page's real Google Lighthouse scores,
        fetched from
      type: object
    types.PageReviewPerformanceAudit:
      description: >
        itself reports it — no Erdo re-scoring. Score is Lighthouse's 0..100
        display score; SavingsMs is the largest reported time saving across the
        audit's overallSavingsMs and its millisecond metricSavings (FCP, LCP,
        TBT, INP), and SavingsBytes is overallSavingsBytes. MetricSavings keeps
        every positive metricSavings entry in its metric's own unit: CLS is a
        unitless layout-shift delta, never milliseconds.
      properties:
        display_value:
          type: string
        id:
          type: string
        metric_savings:
          additionalProperties:
            type: number
          type: object
        savings_bytes:
          type: number
        savings_ms:
          type: number
        score:
          format: int64
          type: integer
        title:
          type: string
      title: >
        PageReviewPerformanceAudit is one opportunity or diagnostic as
        Lighthouse
      type: object
    types.PageReviewSEOAudit:
      description: |
        Lighthouse itself reports it — no Erdo re-scoring.
      properties:
        id:
          type: string
        score:
          format: int64
          type: integer
        title:
          type: string
        weight:
          type: number
      title: >
        PageReviewSEOAudit is one entry of the SEO category's audit composition
        as
      type: object
  responses:
    APIError:
      content:
        application/json:
          schema:
            externalDocs:
              url: https://pkg.go.dev/encore.dev/beta/errs#Error
            properties:
              code:
                description: Error code
                example: not_found
                externalDocs:
                  url: https://pkg.go.dev/encore.dev/beta/errs#ErrCode
                type: string
              details:
                description: Error details
                type: object
              message:
                description: Error message
                type: string
            title: APIError
            type: object
      description: Error response
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: An Erdo API key (erdo_api_...) or scoped token (erdo_token_...).

````

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