> ## Documentation Index
> Fetch the complete documentation index at: https://personal-92-migrate-dev-docs-guides.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Get a hub's items

> Get the items within a single hub specified by identifier



## OpenAPI

````yaml /openapi-with-code-samples.yaml get /hubs/items
openapi: 3.1.1
info:
  title: Plex Media Server
  version: 1.1.1
  license:
    name: Apache 2.0
    url: https://www.apache.org/licenses/LICENSE-2.0.html
servers:
  - url: https://{IP-description}.{identifier}.plex.direct:{port}
    variables:
      identifier:
        description: The unique identifier of this particular PMS
        default: 0123456789abcdef0123456789abcdef
      IP-description:
        description: A `-` separated string of the IPv4 or IPv6 address components
        default: 1-2-3-4
      port:
        default: '32400'
  - url: '{protocol}://{host}:{port}'
    variables:
      protocol:
        description: The network protocol to use. Typically (`http` or `https`)
        default: http
      host:
        description: >
          The Host of the PMS.

          If using on a local network, this is the internal IP address of the
          server hosting the PMS.

          If using on an external network, this is the external IP address for
          your network, and requires port forwarding.

          If using a reverse proxy, this would be the external DNS domain for
          your network, and requires the proxy handle port forwarding. 
        default: localhost
      port:
        description: >
          The Port number configured on the PMS. Typically (`32400`). 

          If using a reverse proxy, this would be the port number configured on
          the proxy.
        default: '32400'
  - url: '{full_server_url}'
    variables:
      full_server_url:
        description: The full manual URL to access the PMS
        default: http://localhost:32400
security:
  - token:
      - shared user
      - admin
tags:
  - name: Activities
    description: >
      Activities provide a way to monitor and control asynchronous operations on
      the server. In order to receive real-time updates for activities, a client
      would normally subscribe via either EventSource or Websocket endpoints.


      Activities are associated with HTTP replies via a special
      `X-Plex-Activity` header which contains the UUID of the activity.


      Activities are optional cancellable. If cancellable, they may be cancelled
      via the `DELETE` endpoint.
  - name: Butler
    description: >-
      The butler is responsible for running periodic tasks.  Some tasks run
      daily, others every few days, and some weekly.  These includes database
      maintenance, metadata updating, thumbnail generation, media analysis, and
      other tasks.
  - name: Collections
    description: API Operations against the Collections
  - name: Content
    description: The actual content of the media provider
  - name: Devices
    description: >
      Media grabbers provide ways for media to be obtained for a given protocol.
      The simplest ones are `stream` and `download`. More complex grabbers can
      have associated devices


      Network tuners can present themselves on the network using the Simple
      Service Discovery Protocol and Plex Media Server will discover them. The
      following XML is an example of the data returned from SSDP. The
      `deviceType`, `serviceType`, and `serviceId` values must remain as they
      are in the example in order for PMS to properly discover the device. Other
      less-obvious fields are described in the parameters section below.


      Example SSDP output

      ```

      <root xmlns="urn:schemas-upnp-org:device-1-0">
          <specVersion>
              <major>1</major>
              <minor>0</minor>
          </specVersion>
          <device>
              <deviceType>urn:plex-tv:device:Media:1</deviceType>
              <friendlyName>Turing Hopper 3000</friendlyName>
              <manufacturer>Plex, Inc.</manufacturer>
              <manufacturerURL>https://plex.tv/</manufacturerURL>
              <modelDescription>Turing Hopper 3000 Media Grabber</modelDescription>
              <modelName>Plex Media Grabber</modelName>
              <modelNumber>1</modelNumber>
              <modelURL>https://plex.tv</modelURL>
              <UDN>uuid:42fde8e4-93b6-41e5-8a63-12d848655811</UDN>
              <serviceList>
                  <service>
                      <URLBase>http://10.0.0.5:8088</URLBase>
                      <serviceType>urn:plex-tv:service:MediaGrabber:1</serviceType>
                      <serviceId>urn:plex-tv:serviceId:MediaGrabber</serviceId>
                  </service>
              </serviceList>
          </device>
      </root>

      ```

        - UDN: (string) A UUID for the device. This should be unique across models of a device at minimum.
        - URLBase: (string) The base HTTP URL for the device from which all of the other endpoints are hosted.
  - name: Download Queue
    description: API Operations against the Download Queue
  - name: DVRs
    description: >
      The DVR provides means to watch and record live TV.  This section of
      endpoints describes how to setup the DVR itself
  - name: EPG
    description: >
      The EPG (Electronic Program Guide) is responsible for obtaining metadata
      for what is airing on each channel and when
  - name: Events
    description: >
      The server can notify clients in real-time of a wide range of events, from
      library scanning, to preferences being modified, to changes to media, and
      many other things. This is also the mechanism by which activity progress
      is reported.


      Two protocols for receiving the events are available: EventSource (also
      known as SSE), and WebSocket.
  - name: General
    description: >-
      General endpoints for basic PMS operation not specific to any media
      provider
  - name: Hubs
    description: The hubs within a media provider
  - name: Library
    description: >-
      Library endpoints which are outside of the Media Provider API.  Typically
      this is manipulation of the library (adding/removing sections, modifying
      preferences, etc).
  - name: Library Collections
    description: >-
      Endpoints for manipulating collections.  In addition to these endpoints,
      `/library/collections/:collectionId/X` will be rerouted to
      `/library/metadata/:collectionId/X` and respond to those endpoints as
      well.
    x-displayName: 'Library: Collections'
  - name: Library Playlists
    description: Endpoints for manipulating playlists.
    x-displayName: 'Library: Playlists'
  - name: Live TV
    description: |
      LiveTV contains the playback sessions of a channel from a DVR device
  - name: Log
    description: Logging mechanism to allow clients to log to the server
  - name: Play Queue
    description: >-
      The playqueue feature within a media provider

      A play queue represents the current list of media for playback. Although
      queues are persisted by the server, they should be regarded by the user as
      a fairly lightweight, an ephemeral list of items queued up for playback in
      a session.  There is generally one active queue for each type of media
      (music, video, photos) that can be added to or destroyed and replaced with
      a fresh queue.

      Play Queues has a region, which we refer to in this doc (partially for
      historical reasons) as "Up Next". This region is defined by
      `playQueueLastAddedItemID` existing on the media container. This follows
      iTunes' terminology. It is a special region after the currently playing
      item but before the originally-played items. This enables "Party Mode"
      listening/viewing, where items can be added on-the-fly, and normal queue
      playback resumed when completed. 

      You can visualize the play queue as a sliding window in the complete list
      of media queued for playback. This model is important when scaling to
      larger play queues (e.g. shuffling 40,000 audio tracks). The client only
      needs visibility into small areas of the queue at any given time, and the
      server can optimize access in this fashion.

      All created play queues will have an empty "Up Next" area - unless the
      item is an album and no `key` is provided. In this case the "Up Next" area
      will be populated by the contents of the album. This is to allow queueing
      of multiple albums - since the 'Add to Up Next' will insert after all the
      tracks. This means that If you're creating a PQ from an album, you can
      only shuffle it if you set `key`. This is due to the above implicit
      queueing of albums when no `key` is provided as well as the current
      limitation that you cannot shuffle a PQ with an "Up Next" area.

      The play queue window advances as the server receives timeline requests.
      The client needs to retrieve the play queue as the “now playing” item
      changes. There is no play queue API to update the playing item.
  - name: Playlist
    description: Media playlists that can be created and played back
  - name: Preferences
    description: API Operations against the Preferences
  - name: Provider
    description: >-
      Media providers are the starting points for the entire Plex Media Server
      media library API.  It defines the paths for the groups of endpoints.  The
      `/media/providers` should be the only hard-coded path in clients when
      accessing the media library.  Non-media library endpoints are outside the
      scope of the media provider.  See the description in See [the section in
      API Info](#section/API-Info/Media-Providers) for more information on how
      to use media providers.
  - name: Rate
    description: Operations for rating media items (thumbs up/down, star ratings, etc.)
  - name: Search
    description: The search feature within a media provider
  - name: Status
    description: >-
      The status endpoints give you information about current playbacks, play
      history, and even terminating sessions.
  - name: Subscriptions
    description: >
      Subscriptions determine which media will be recorded and the criteria for
      selecting an airing when multiple are available
  - name: Timeline
    description: The actions feature within a media provider
  - name: Transcoder
    description: API Operations against the Transcoder
  - name: UltraBlur
    description: Service provided to compute UltraBlur colors and images.
  - name: Updater
    description: >
      This describes the API for searching and applying updates to the Plex
      Media Server.

      Updates to the status can be observed via the Event API.
paths:
  /hubs/items:
    get:
      tags:
        - Hubs
      summary: Get a hub's items
      description: Get the items within a single hub specified by identifier
      operationId: getHubItems
      parameters:
        - $ref: '#/components/parameters/accepts'
        - $ref: '#/components/parameters/X-Plex-Client-Identifier'
        - $ref: '#/components/parameters/X-Plex-Product'
        - $ref: '#/components/parameters/X-Plex-Version'
        - $ref: '#/components/parameters/X-Plex-Platform'
        - $ref: '#/components/parameters/X-Plex-Platform-Version'
        - $ref: '#/components/parameters/X-Plex-Device'
        - $ref: '#/components/parameters/X-Plex-Model'
        - $ref: '#/components/parameters/X-Plex-Device-Vendor'
        - $ref: '#/components/parameters/X-Plex-Device-Name'
        - $ref: '#/components/parameters/X-Plex-Marketplace'
        - $ref: '#/components/parameters/count'
        - name: identifier
          description: If provided, limit to only specified hubs
          in: query
          required: true
          schema:
            type: array
            items:
              type: string
      responses:
        '200':
          description: OK
          headers:
            X-Plex-Container-Start:
              $ref: '#/components/headers/X-Plex-Container-Start'
            X-Plex-Container-Total-Size:
              $ref: '#/components/headers/X-Plex-Container-Total-Size'
          content:
            application/json:
              schema:
                properties:
                  MediaContainer:
                    $ref: '#/components/schemas/MediaContainer'
                type: object
        '404':
          description: The specified hub could not be found
          content:
            text/html: {}
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: "package main\n\nimport(\n\t\"context\"\n\t\"github.com/LukeHagar/plexgo/models/components\"\n\t\"github.com/LukeHagar/plexgo\"\n\t\"github.com/LukeHagar/plexgo/models/operations\"\n\t\"log\"\n)\n\nfunc main() {\n    ctx := context.Background()\n\n    s := plexgo.New(\n        plexgo.WithAccepts(components.AcceptsApplicationXML),\n        plexgo.WithClientIdentifier(\"abc123\"),\n        plexgo.WithProduct(\"Plex for Roku\"),\n        plexgo.WithVersion(\"2.4.1\"),\n        plexgo.WithPlatform(\"Roku\"),\n        plexgo.WithPlatformVersion(\"4.3 build 1057\"),\n        plexgo.WithDevice(\"Roku 3\"),\n        plexgo.WithModel(\"4200X\"),\n        plexgo.WithDeviceVendor(\"Roku\"),\n        plexgo.WithDeviceName(\"Living Room TV\"),\n        plexgo.WithMarketplace(\"googlePlay\"),\n        plexgo.WithSecurity(\"<YOUR_API_KEY_HERE>\"),\n    )\n\n    res, err := s.Hubs.GetHubItems(ctx, operations.GetHubItemsRequest{\n        Identifier: []string{\n            \"<value 1>\",\n            \"<value 2>\",\n            \"<value 3>\",\n        },\n    })\n    if err != nil {\n        log.Fatal(err)\n    }\n    if res.Object != nil {\n        // handle response\n    }\n}"
        - lang: java
          label: PlexJava
          source: |-
            package hello.world;

            import dev.plexapi.sdk.PlexAPI;
            import dev.plexapi.sdk.models.operations.GetHubItemsRequest;
            import dev.plexapi.sdk.models.operations.GetHubItemsResponse;
            import dev.plexapi.sdk.models.shared.Accepts;
            import java.lang.Exception;
            import java.util.List;

            public class Application {

                public static void main(String[] args) throws Exception {

                    PlexAPI sdk = PlexAPI.builder()
                            .accepts(Accepts.APPLICATION_XML)
                            .clientIdentifier("abc123")
                            .product("Plex for Roku")
                            .version("2.4.1")
                            .platform("Roku")
                            .platformVersion("4.3 build 1057")
                            .device("Roku 3")
                            .model("4200X")
                            .deviceVendor("Roku")
                            .deviceName("Living Room TV")
                            .marketplace("googlePlay")
                            .token(System.getenv().getOrDefault("TOKEN", ""))
                        .build();

                    GetHubItemsRequest req = GetHubItemsRequest.builder()
                            .identifier(List.of(
                                "<value 1>",
                                "<value 2>",
                                "<value 3>"))
                            .build();

                    GetHubItemsResponse res = sdk.hubs().getHubItems()
                            .request(req)
                            .call();

                    if (res.object().isPresent()) {
                        // handle response
                    }
                }
            }
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@lukehagar/plexjs";
            import { Accepts } from "@lukehagar/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: Accepts.ApplicationXml,
              clientIdentifier: "abc123",
              product: "Plex for Roku",
              version: "2.4.1",
              platform: "Roku",
              platformVersion: "4.3 build 1057",
              device: "Roku 3",
              model: "4200X",
              deviceVendor: "Roku",
              deviceName: "Living Room TV",
              marketplace: "googlePlay",
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.hubs.getHubItems({
                identifier: [
                  "<value 1>",
                  "<value 2>",
                  "<value 3>",
                ],
              });

              console.log(result);
            }

            run();
components:
  parameters:
    accepts:
      name: accepts
      description: Indicates the client accepts the indicated media types
      in: header
      schema:
        type: string
        default: application/xml
        enum:
          - application/json
          - application/xml
    X-Plex-Client-Identifier:
      name: X-Plex-Client-Identifier
      x-speakeasy-name-override: Client-Identifier
      in: header
      description: An opaque identifier unique to the client
      required: true
      schema:
        type: string
        example: abc123
      example: abc123
    X-Plex-Product:
      name: X-Plex-Product
      x-speakeasy-name-override: Product
      in: header
      description: The name of the client product
      schema:
        type: string
        example: Plex for Roku
      example: Plex for Roku
    X-Plex-Version:
      name: X-Plex-Version
      x-speakeasy-name-override: Version
      in: header
      description: The version of the client application
      schema:
        type: string
        example: 2.4.1
      example: 2.4.1
    X-Plex-Platform:
      name: X-Plex-Platform
      x-speakeasy-name-override: Platform
      in: header
      description: The platform of the client
      schema:
        type: string
        example: Roku
      example: Roku
    X-Plex-Platform-Version:
      name: X-Plex-Platform-Version
      x-speakeasy-name-override: Platform-Version
      in: header
      description: The version of the platform
      schema:
        type: string
        example: 4.3 build 1057
      example: 4.3 build 1057
    X-Plex-Device:
      name: X-Plex-Device
      x-speakeasy-name-override: Device
      in: header
      description: A relatively friendly name for the client device
      schema:
        type: string
        example: Roku 3
      example: Roku 3
    X-Plex-Model:
      name: X-Plex-Model
      x-speakeasy-name-override: Model
      in: header
      description: A potentially less friendly identifier for the device model
      schema:
        type: string
        example: 4200X
      example: 4200X
    X-Plex-Device-Vendor:
      name: X-Plex-Device-Vendor
      x-speakeasy-name-override: Device-Vendor
      in: header
      description: The device vendor
      schema:
        type: string
        example: Roku
      example: Roku
    X-Plex-Device-Name:
      name: X-Plex-Device-Name
      x-speakeasy-name-override: Device-Name
      in: header
      description: A friendly name for the client
      schema:
        type: string
        example: Living Room TV
      example: Living Room TV
    X-Plex-Marketplace:
      name: X-Plex-Marketplace
      x-speakeasy-name-override: Marketplace
      in: header
      description: The marketplace on which the client application is distributed
      schema:
        type: string
        example: googlePlay
      example: googlePlay
    count:
      name: count
      description: Limit results to count items
      in: query
      schema:
        type: integer
  headers:
    X-Plex-Container-Start:
      description: >-
        Provided on all MediaContainer objects indicating the offset of where
        this container page starts
      schema:
        type: integer
    X-Plex-Container-Total-Size:
      description: >-
        Provided on all MediaContainer objects indicating the total size of the
        collection
      schema:
        type: integer
        minimum: 0
        example: 100
  schemas:
    MediaContainer:
      description: >
        `MediaContainer` is the root element of most Plex API responses. It
        serves as a generic container for various types of content (Metadata,
        Hubs, Directories, etc.) and includes pagination information (offset,
        size, totalSize) when applicable.

        Common attributes: - identifier: Unique identifier for this container -
        size: Number of items in this response page - totalSize: Total number of
        items available (for pagination) - offset: Starting index of this page
        (for pagination)

        The container often "hoists" common attributes from its children. For
        example, if all tracks in a container share the same album title, the
        `parentTitle` attribute may appear on the MediaContainer rather than
        being repeated on each track.
      type: object
      properties:
        identifier:
          type: string
        offset:
          description: >
            The offset of where this container page starts among the total
            objects available. Also provided in the `X-Plex-Container-Start`
            header.
          type: integer
        size:
          type: integer
        totalSize:
          description: >
            The total size of objects available. Also provided in the
            `X-Plex-Container-Total-Size` header.
          type: integer
  securitySchemes:
    token:
      name: X-Plex-Token
      description: >
        The token which identifies the user accessing the PMS. This can be
        either:

        - A traditional access token obtained from plex.tv

        - A JWT token obtained through the JWT authentication flow


        JWT tokens provide better security with:

        - Short-lived tokens (7 days expiration)

        - Public-key cryptography (ED25519)

        - Better clock synchronization

        - Individual device revocation capability
      type: apiKey
      in: header

````