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

# List channel commentary across people

> [OpenAPI JSON Spec](/docs/output/v1_persons_channel-commentary_get.json)
Same rows as /v1/persons/{person_id}/channel-commentary without fixing the person. Browse by said_on day with start_time and end_time, which returns the rows that are served now. Or poll changes with updated_after and updated_before (unix seconds, [after, before), ordered by updated_at then id, paged by pagination.cursor; see docs/api/update-polling.md and docs/api/person-channel-commentary-updates.md). An update window returns every row whose latest change falls in it, and state says which kind it is. A row whose state is served has every field. A row whose state is duplicate (the page reports a remark another page holds in full), pending (a report still being traced back to where it was said, or a YouTube video whose speakers are not known yet) or refused has only id, updated_at, state and person.id: it is not output, and a consumer that holds its id drops it. A duplicate or pending row can come back as served later. Poll by updated_at, never by said_on: rows arrive with old said_on days. person_id is an optional filter. No row for a person and day does not mean they said nothing: a remark is stored only when its page can be read and the sentence checked against it.



## OpenAPI

````yaml /api-reference/openapi.json get /v1/persons/channel-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/channel-commentary:
    get:
      tags:
        - Persons
      summary: List channel commentary across people
      description: >-
        [OpenAPI JSON Spec](/docs/output/v1_persons_channel-commentary_get.json)

        Same rows as /v1/persons/{person_id}/channel-commentary without fixing
        the person. Browse by said_on day with start_time and end_time, which
        returns the rows that are served now. Or poll changes with updated_after
        and updated_before (unix seconds, [after, before), ordered by updated_at
        then id, paged by pagination.cursor; see docs/api/update-polling.md and
        docs/api/person-channel-commentary-updates.md). An update window returns
        every row whose latest change falls in it, and state says which kind it
        is. A row whose state is served has every field. A row whose state is
        duplicate (the page reports a remark another page holds in full),
        pending (a report still being traced back to where it was said, or a
        YouTube video whose speakers are not known yet) or refused has only id,
        updated_at, state and person.id: it is not output, and a consumer that
        holds its id drops it. A duplicate or pending row can come back as
        served later. Poll by updated_at, never by said_on: rows arrive with old
        said_on days. person_id is an optional filter. No row for a person and
        day does not mean they said nothing: a remark is stored only when its
        page can be read and the sentence checked against it.
      parameters:
        - description: Person registry id (uuid) to narrow to one person
          in: query
          name: person_id
          schema:
            type: string
        - description: >-
            Browse range start, unix seconds; required unless updated_after is
            given
          in: query
          name: start_time
          schema:
            type: integer
        - description: >-
            Browse range end, unix seconds; required unless updated_after is
            given
          in: query
          name: end_time
          schema:
            type: integer
        - description: Update window start, unix seconds, inclusive
          in: query
          name: updated_after
          schema:
            type: integer
        - description: Update window end, unix seconds, exclusive
          in: query
          name: updated_before
          schema:
            type: integer
        - description: Opaque continuation of an update window
          in: query
          name: cursor
          schema:
            type: string
        - description: >-
            default 100, or 50 with include_body; 1 to 500, at most 50 with
            include_body
          in: query
          name: limit
          schema:
            type: integer
        - description: Rows to skip; browse only
          in: query
          name: offset
          schema:
            type: integer
        - description: Return each row's full body
          in: query
          name: include_body
          schema:
            type: boolean
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/model.APIResponse'
                  - properties:
                      data:
                        items:
                          $ref: '#/components/schemas/model.PersonChannelCommentary'
                        type: array
                    type: object
        '400':
          description: Bad Request
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/model.APIResponse'
        '503':
          description: Service Unavailable
          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.PersonChannelCommentary:
      properties:
        body:
          description: >-
            Body is the page's text as read. It is returned only when the
            request sets

            include_body=true, and limit is then at most 50 because rows that
            carry a page of text

            are large. It can hold words that are not the person's, so Quote
            stays the sentence

            attributed to them.
          type: string
        context:
          description: >-
            Context holds the posts this one answers, quotes or forwards, each
            with its own author.

            It is other people's words and never part of Quote or Body. An empty
            array, never null,

            when there are none.
          items:
            $ref: '#/components/schemas/model.PersonCommentaryContext'
          type: array
        form:
          description: >-
            Form is how the page holds the person's words: "post" for a post on
            a social platform,

            "article" for any other written page, such as a press release that
            quotes the person,

            "transcript" for spoken words written down, and only for these: the
            captions of a video,

            an episode of the podcast library, a page a transcript site
            published, or a page with a

            speaker label for the person that the gate can read. The whole of an
            own post or article

            is the person's; a transcript also holds the words of others who
            speak in it.
          enum:
            - post
            - article
            - transcript
          type: string
        id:
          description: >-
            ID is the row's fixed identity, derived from the person, the day and
            the page, so it

            stays the same when the row is rewritten. An update window is
            ordered by updated_at,

            then id.
          type: string
        item_ref:
          allOf:
            - $ref: '#/components/schemas/model.ChannelCommentaryItemRef'
          description: >-
            ItemRef names the row of another Arrays endpoint that this page is;
            null when the page

            is no such row.
        own:
          description: >-
            Own is true when the page is the person's own: their post, their
            channel, their column.
          type: boolean
        person:
          allOf:
            - $ref: '#/components/schemas/model.ChannelCommentaryPerson'
          description: Person is who said it.
        published_at:
          description: >-
            PublishedAt is when the page says it was published, unix seconds. A
            document the

            person's own site lists without a date of its own, such as a
            shareholder letter in

            PDF, has the time the site first listed it, to within a few hours.
            Null when the page

            states no time and only the time it was read is known.
          type: integer
        publisher:
          description: >-
            Publisher is the media, publication or program that published the
            page. Null when

            the page is on a platform (X, YouTube, Xueqiu, Apple Podcasts and
            the like) that names

            no one else, and for the person's own post on a platform.
          type: string
        quote:
          description: >-
            Quote is the one sentence the person said, character for character
            as the page prints

            it. On a captions page (a YouTube video) the time marks the page
            puts between its

            blocks ("[00:58]") are taken out of it. On a YouTube row whose quote
            was checked against

            the audio of the video (quote_speaker is present), it is the
            sentence of the audio

            transcript, as the turns print it, and not the one in the captions.
          type: string
        quote_offset_sec:
          description: >-
            QuoteOffsetSec is where in the video the turn that holds the first
            word of the quote

            starts, in seconds from the start of the video. There is no time for
            a word, so the

            quote is somewhere between this and the end of that turn. Present
            exactly when

            quote_speaker is: 0 is a start time too.
          type: number
        quote_speaker:
          description: >-
            QuoteSpeaker is the label of the voice that said the quote, the
            voice of one entry of

            turns and a key of resolved_speakers. It is there only on a YouTube
            row whose quote was

            checked against the audio of its video, and the voice is the
            person's. Left out

            otherwise.
          type: string
        resolved_speakers:
          additionalProperties:
            $ref: '#/components/schemas/model.ChannelCommentarySpeaker'
          description: >-
            ResolvedSpeakers says who each voice of the video is, by the voice
            label of the turns.

            It is the same list as resolved_speakers of
            /api/v1/other/podcast/transcripts, with the

            same fields (without presence): join on person_id, which is the
            person registry's id as

            /api/v1/persons answers with it. A voice that was given no name is
            not in it, nor is one

            named with a confidence below 0.4, as in that endpoint, and shows
            only in turns. It is

            there with every row whose quote was checked against the audio, with
            or without

            include_body, and left out otherwise.
          type: object
        said_at:
          description: >-
            SaidAt is when the person said it, unix seconds; null when that is
            not known.
          type: integer
        state:
          description: State is "served", "duplicate", "pending" or "refused".
          enum:
            - served
            - duplicate
            - pending
            - refused
          type: string
        title:
          description: >-
            Title is the page's title; null when the page has none, as a post
            has none.
          type: string
        turns:
          description: >-
            Turns is the whole video, in order, as the audio of the video was
            transcribed: who spoke

            (speaker, a name when the voice has one, and voice) and when
            (start_sec, end_sec) for

            each stretch of speech. It is returned only when the request sets
            include_body=true, as

            body is, and only on a YouTube row whose quote was checked against
            the audio. It holds

            the words of everyone who speaks in the video: the turns whose voice
            is the person's

            (the key of the resolved_speakers entry with the person's id, or
            quote_speaker) are

            theirs, except a turn that entry lists in unknown_turn_indexes, and
            the rest are not.
          items:
            $ref: '#/components/schemas/model.ChannelCommentaryTurn'
          type: array
        updated_at:
          description: >-
            UpdatedAt is when this row last changed, as RFC3339 UTC with
            fractional seconds. A

            change of state is a change: updated_after and updated_before on

            /api/v1/persons/channel-commentary filter on it.
          type: string
        url:
          description: URL is the address of the page, after the fetcher resolved it.
          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.PersonCommentaryContext:
      properties:
        author_handle:
          type: string
        author_id:
          description: >-
            AuthorID, AuthorHandle and AuthorName are what the platform gave for
            the

            post's author, each left out when it gave none.
          type: string
        author_name:
          type: string
        depth:
          description: >-
            Depth is 1 for the post the row answers directly, then 2 and 3 for
            the

            posts above it.
          type: integer
        published_at:
          description: PublishedAt is unix seconds, 0 when the platform gave no time.
          type: integer
        relation:
          description: >-
            Relation is "reply_to", "quoted", "forwarded", "reshared" or
            "thread_root".
          type: string
        status:
          description: >-
            Status is "ok", "deleted" or "unavailable". Anything but "ok" means
            the

            post could not be read in full, and the row's ReplyStatus says so.
          type: string
        text:
          description: Text is the post's text as the platform gave it.
          type: string
        url:
          description: URL is the address of this post.
          type: string
      type: object
    model.ChannelCommentaryItemRef:
      properties:
        endpoint:
          description: >-
            Endpoint is the path of the endpoint that serves the row:

            "/api/v1/social-feeds/x/search",
            "/api/v1/other/podcast/transcripts",

            "/api/v1/stocks/tv-news" or "/api/v1/stocks/market-news".
          type: string
        id:
          description: >-
            ID is that row's key exactly as that endpoint returns it, written as
            a string: the

            post's platform_id, the transcript's id, the story_id, or the
            article's id.
          type: string
      type: object
    model.ChannelCommentaryPerson:
      properties:
        id:
          description: >-
            ID is the person registry's id, the same one /api/v1/persons answers
            with.
          type: string
        name:
          description: >-
            Name is the registry's display_name, the name /api/v1/persons
            answers with; null when

            the registry has no name for the person.
          type: string
      type: object
    model.ChannelCommentarySpeaker:
      properties:
        attribution_source:
          description: >-
            AttributionSource is how the name was reached: intro_selfstated,
            intro_introduced,

            signoff, title, websearch, or adjudicated. Per voice, since one
            video mixes them.
          type: string
        confidence:
          description: >-
            Confidence runs 0..1. Below 0.4 is already dropped; at or above 0.7
            use it, between

            the two show it as uncertain. An entry stored without one stays and
            reports 0.
          type: number
        name:
          description: >-
            Name is the spelling found on a source, not the one in the audio
            transcript.
          type: string
        person_id:
          description: >-
            PersonID is the person registry id, as /api/v1/persons answers with
            it. Absent when the

            name matched no one in the registry: the name was heard, and nothing
            says who it is.
          type: string
        role:
          description: >-
            Role is host, guest, or clip: the show plays a recording of this
            person made somewhere

            else, and they were not in the video.
          enum:
            - host
            - guest
            - clip
          example: guest
          type: string
        unknown_turn_indexes:
          description: >-
            UnknownTurnIndexes are the zero-based positions, in turns, of turns
            of this voice that

            cannot be attributed to the person it names.
          items:
            type: integer
          type: array
      type: object
    model.ChannelCommentaryTurn:
      properties:
        end_sec:
          description: >-
            EndSec is the end of the turn, in seconds from the start of the
            video.
          type: number
        speaker:
          description: >-
            Speaker is who said the turn: the name of the voice's entry in
            resolved_speakers. A

            voice with no entry there (it was given no name, or a name below
            0.4) shows its voice

            label, such as "spk 3", and so does a turn that the entry lists in

            unknown_turn_indexes.
          example: Arthur Hayes
          type: string
        start_sec:
          description: >-
            StartSec is the start of the turn, in seconds from the start of the
            video.
          type: number
        text:
          description: Text is what the voice said in this turn.
          type: string
        voice:
          description: >-
            Voice is the voice's label in this video, such as "spk 3", whether
            or not speaker

            shows a name. It is a key of resolved_speakers when the voice was
            given a name, and the

            value quote_speaker takes.
          example: spk 3
          type: string
      type: object
    model.APIErrorDetail:
      properties:
        field:
          type: string
        got:
          type: string
        reason:
          type: string
      type: object

````

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