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

# Get what a person said in public

> [OpenAPI JSON Spec](/docs/output/v1_persons_person-id_commentary_get.json)
One row per source document: a page, one sentence the person said on it, and where. Every row is the place the remark was made, their own post, the venue's own transcript, or the outlet that interviewed them; a site reporting what they said elsewhere is not stored. Rows carrying the same remark share a cluster_id.



## OpenAPI

````yaml /api-reference/openapi.json get /v1/persons/{person_id}/commentary
openapi: 3.0.0
info:
  contact: {}
  description: >-
    Welcome to Arrays!


    Arrays is a unified financial data layer for both financial institutions and
    retail users, delivering comprehensive market data across crypto and equity
    markets. Our datasets cover fundamentals, ETFs, options, crypto, and more.


    Visit [arrays.org](https://arrays.org) to request an API key and start your
    free trial. You can explore our full API offerings in the documentation
    below.


    For any questions regarding APIs or pricing, please contact
    support@arrays.org.
  title: Arrays API
  version: '1.0'
servers:
  - url: https://data-tools.prd.arrays.org/api
security: []
paths:
  /v1/persons/{person_id}/commentary:
    get:
      tags:
        - Persons
      summary: Get what a person said in public
      description: >-
        [OpenAPI JSON
        Spec](/docs/output/v1_persons_person-id_commentary_get.json)

        One row per source document: a page, one sentence the person said on it,
        and where. Every row is the place the remark was made, their own post,
        the venue's own transcript, or the outlet that interviewed them; a site
        reporting what they said elsewhere is not stored. Rows carrying the same
        remark share a cluster_id.
      parameters:
        - description: >-
            Person registry id (uuid), as /api/v1/persons returns. Resolve a
            name with /api/v1/persons?name=...
          in: path
          name: person_id
          required: true
          schema:
            type: string
        - description: Range start, unix seconds
          in: query
          name: start_time
          required: true
          schema:
            type: integer
        - description: Range end, unix seconds
          in: query
          name: end_time
          required: true
          schema:
            type: integer
        - description: Page size, 1 to 500
          in: query
          name: limit
          schema:
            type: integer
        - description: Rows to skip
          in: query
          name: offset
          schema:
            type: integer
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/model.APIResponse'
                  - properties:
                      data:
                        items:
                          $ref: '#/components/schemas/model.PersonCommentary'
                        type: array
                    type: object
        '400':
          description: Bad Request
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/model.APIResponse'
components:
  schemas:
    model.APIResponse:
      properties:
        data: {}
        error:
          $ref: '#/components/schemas/model.APIError'
        metadata: {}
        pagination: {}
        request_id:
          type: string
        success:
          type: boolean
      type: object
    model.PersonCommentary:
      properties:
        author:
          description: |-
            Author is what the page said about who wrote it, empty when it said
            nothing.
          type: string
        cluster_id:
          description: >-
            ClusterID groups the rows carrying the same remark, which is how one

            thing said on X and on LinkedIn reads as one thing. A remark that
            appears

            in one place carries its own URL here, so grouping needs no special
            case.
          type: string
        lang:
          type: string
        own_channel_verified:
          description: >-
            OwnChannelVerified is set only for "own": "author" when the page
            named

            this person, "channel" when the address is a configured one of
            theirs,

            "unverified" when neither could answer.
          type: string
        page_title:
          description: >-
            PageTitle and Venue describe where it was said. Venue is the
            program,

            publication or platform.
          type: string
        person_id:
          description: >-
            PersonID is the person registry's id, the same one /api/v1/persons

            answers with. Resolve a name to one with /api/v1/persons?name=...
            first.
          type: string
        published_at:
          description: |-
            PublishedAt is unix seconds, from the page itself unless
            PublishedAtSource says otherwise.
          type: integer
        published_at_source:
          description: >-
            PublishedAtSource is "page" when the page stated the time and
            "fetch"

            when it stated none and the retrieval time stands in. A consumer
            ordering

            a timeline wants the first kind; one counting coverage wants both.
          type: string
        quote:
          description: >-
            Quote is one sentence, character for character as the page prints
            it.
          type: string
        said_on:
          description: SaidOn is the UTC day this row belongs to.
          type: string
        source_kind:
          description: SourceKind is "own", "transcript" or "interview".
          type: string
        url:
          description: >-
            URL is the address the text was read from, after the fetcher
            resolved it.
          type: string
        venue:
          type: string
      type: object
    model.APIError:
      properties:
        code:
          example: RESOURCE_NOT_FOUND
          type: string
        details:
          items:
            $ref: '#/components/schemas/model.APIErrorDetail'
          type: array
        docs_url:
          type: string
        examples:
          items:
            type: string
          type: array
        hint:
          type: string
        message:
          example: The requested resource was not found.
          type: string
        suggestions:
          items:
            type: string
          type: array
      type: object
    model.APIErrorDetail:
      properties:
        field:
          type: string
        got:
          type: string
        reason:
          type: string
      type: object

````