mirror of
https://github.com/LukeHagar/plexjava.git
synced 2025-12-06 04:20:46 +00:00
1e29008284
* `plex-api.libraryPlaylists.addPlaylistItems()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.libraryPlaylists.clearPlaylistItems()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.libraryCollections.moveCollectionItem()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.libraryCollections.deleteCollectionItem()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.libraryCollections.addCollectionItems()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.content.getSonicallySimilar()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.butler.stopTask()`: `request` **Changed** **Breaking** ⚠️ * `plex-api.butler.startTask()`: `request` **Changed** **Breaking** ⚠️ * `plex-api.content.getSonicPath()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.downloadQueue.getItemDecision()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.hubs.getAllHubs()`: * `request.onlyTransient` **Changed** * `response.mediacontainer.hub.[].metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.hubs.getContinueWatching()`: `response.mediacontainer.hub.[].metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.hubs.getPromotedHubs()`: `response.mediacontainer.hub.[].metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.hubs.getMetadataHubs()`: * `request.onlyTransient` **Changed** * `response.mediacontainer.hub.[].metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.hubs.getPostplayHubs()`: * `request.onlyTransient` **Changed** * `response.mediacontainer.hub.[].metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.hubs.getRelatedHubs()`: * `request.onlyTransient` **Changed** * `response.mediacontainer.hub.[].metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.hubs.getSectionHubs()`: * `request.onlyTransient` **Changed** * `response.mediacontainer.hub.[].metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.content.getAllLeaves()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.content.listContent()`: * `request` **Changed** * `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.search.searchHubs()`: `response.mediacontainer.hub.[].metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.content.getAlbums()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.getLibraryItems()`: * `request.mediaQuery` **Changed** * `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.ingestTransientItem()`: * `request` **Changed** * `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.getLibraryMatches()`: * `request` **Changed** **Breaking** ⚠️ * `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.content.getMetadataItem()`: * `request` **Changed** * `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.getSections()`: `response.mediacontainer.directory.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.addSection()`: * `request` **Changed** * `response.mediacontainer.directory.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.getTags()`: * `request.type` **Changed** **Breaking** ⚠️ * `plex-api.content.getCollectionItems()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.getAllItemLeaves()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.status.listSessions()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.playQueue.movePlayQueueItem()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.getExtras()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.playQueue.deletePlayQueueItem()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.playQueue.unshuffle()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.listMatches()`: * `request.manual` **Changed** * `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.listSonicallySimilar()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.playQueue.shuffle()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.getRelatedItems()`: `response.mediacontainer.hub.[].metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.listSimilar()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.playQueue.resetPlayQueue()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.getItemTree()`: `response.mediacontainer.metadataItem.[]` **Changed** **Breaking** ⚠️ * `plex-api.playQueue.clearPlayQueue()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.playQueue.addToPlayQueue()`: * `request.next` **Changed** * `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.getCommon()`: * `request.mediaQuery` **Changed** * `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.getPerson()`: `response.mediacontainer.directory.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.listPersonMedia()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.playQueue.getPlayQueue()`: * `request` **Changed** * `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.getLibraryDetails()`: * `request.includeDetails` **Changed** * `response.mediacontainer.directory.[]` **Changed** **Breaking** ⚠️ * `plex-api.libraryPlaylists.movePlaylistItem()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.autocomplete()`: * `request.mediaQuery` **Changed** * `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.library.getCollections()`: * `request.mediaQuery` **Changed** * `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.libraryPlaylists.getPlaylistGeneratorItems()`: `response.mediacontainer.metadata` **Changed** **Breaking** ⚠️ * `plex-api.libraryPlaylists.deletePlaylistItem()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.search.voiceSearchHubs()`: * `request.type` **Changed** **Breaking** ⚠️ * `response.mediacontainer.hub.[].metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.libraryPlaylists.createPlaylist()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.playlist.getPlaylistItems()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.playlist.getPlaylist()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.playlist.listPlaylists()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.collections.createCollection()`: * `request.type` **Changed** **Breaking** ⚠️ * `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.dvRs.tuneChannel()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.liveTv.getSessions()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.liveTv.getLiveTvSession()`: `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.transcoder.makeDecision()`: * `request` **Changed** * `response.mediacontainer.metadata.[]` **Changed** **Breaking** ⚠️ * `plex-api.subscriptions.getAllSubscriptions()`: * `request` **Changed** * `response.mediacontainer.mediaSubscription.[].mediaGrabOperation.[].metadata` **Changed** **Breaking** ⚠️ * `plex-api.subscriptions.createSubscription()`: `response.mediacontainer.mediaSubscription.[].mediaGrabOperation.[].metadata` **Changed** **Breaking** ⚠️ * `plex-api.subscriptions.getScheduledRecordings()`: `response.mediacontainer.mediaGrabOperation.[].metadata` **Changed** **Breaking** ⚠️ * `plex-api.subscriptions.getTemplate()`: `response.mediacontainer.subscriptionTemplate.[].mediaSubscription.[].mediaGrabOperation.[].metadata` **Changed** **Breaking** ⚠️ * `plex-api.subscriptions.getSubscription()`: * `request` **Changed** * `response.mediacontainer.mediaSubscription.[].mediaGrabOperation.[].metadata` **Changed** **Breaking** ⚠️ * `plex-api.subscriptions.editSubscriptionPreferences()`: `response.mediacontainer.mediaSubscription.[].mediaGrabOperation.[].metadata` **Changed** **Breaking** ⚠️ * `plex-api.subscriptions.reorderSubscription()`: `response.mediacontainer.mediaSubscription.[].mediaGrabOperation.[].metadata` **Changed** **Breaking** ⚠️ * `plex-api.library.addSubtitles()`: `request` **Changed** * `plex-api.libraryPlaylists.uploadPlaylist()`: * `request.force` **Changed** * `plex-api.transcoder.transcodeSubtitles()`: `request` **Changed** * `plex-api.transcoder.startTranscodeSession()`: `request` **Changed** * `plex-api.library.getMediaPart()`: * `request.download` **Changed** * `plex-api.library.detectIntros()`: * `request.force` **Changed** * `plex-api.library.getSectionImage()`: * `request.mediaQuery` **Changed** * `plex-api.library.deleteMediaItem()`: * `request.proxy` **Changed** * `plex-api.library.refreshItemsMetadata()`: * `request.markUpdated` **Changed** * `plex-api.authentication.postUsersSignInData()`: **Added** * `plex-api.authentication.getTokenDetails()`: **Added** * `plex-api.library.detectCredits()`: `request` **Changed** * `plex-api.library.setStreamSelection()`: * `request.allParts` **Changed** * `plex-api.library.updateItems()`: * `request.field.locked` **Changed** * `plex-api.playQueue.createPlayQueue()`: `request` **Changed** * `plex-api.library.deleteLibrarySection()`: * `request.async` **Changed** * `plex-api.library.getAugmentationStatus()`: * `request.wait` **Changed** * `plex-api.transcoder.transcodeImage()`: `request` **Changed** * `plex-api.devices.modifyDevice()`: * `request.enabled` **Changed** * `plex-api.library.detectVoiceActivity()`: `request` **Changed** * `plex-api.library.getStream()`: * `request.autoAdjustSubtitle` **Changed** * `plex-api.library.startBifGeneration()`: * `request.force` **Changed** * `plex-api.library.getFirstCharacters()`: * `request.mediaQuery` **Changed** * `plex-api.ultraBlur.getImage()`: * `request.noise` **Changed** * `plex-api.library.generateThumbs()`: * `request.force` **Changed** * `plex-api.updater.applyUpdates()`: `request` **Changed** * `plex-api.updater.checkUpdates()`: * `request.download` **Changed** * `plex-api.library.deleteMetadataItem()`: * `request.proxy` **Changed** * `plex-api.library.optimizeDatabase()`: * `request.async` **Changed** * `plex-api.library.refreshSection()`: * `request.force` **Changed** * `plex-api.hubs.updateHubVisibility()`: `request` **Changed** * `plex-api.hubs.createCustomHub()`: `request` **Changed** * `plex-api.downloadQueue.addDownloadQueueItems()`: `request` **Changed** * `plex-api.timeline.report()`: `request` **Changed** * `plex-api.general.getSourceConnectionInformation()`: * `request.refresh` **Changed** * `plex-api.plex.getServerResources()`: **Added** * `plex-api.users.getUsers()`: **Added**
222 KiB
222 KiB
Library
(library())
Overview
Library endpoints which are outside of the Media Provider API. Typically this is manipulation of the library (adding/removing sections, modifying preferences, etc).
Available Operations
- getLibraryItems - Get all items in library
- deleteCaches - Delete library caches
- cleanBundles - Clean bundles
- ingestTransientItem - Ingest a transient item
- getLibraryMatches - Get library matches
- optimizeDatabase - Optimize the Database
- getRandomArtwork - Get random artwork
- getSections - Get library sections (main Media Provider Only)
- addSection - Add a library section
- stopAllRefreshes - Stop refresh
- getSectionsPrefs - Get section prefs
- refreshSectionsMetadata - Refresh all sections
- getTags - Get all library tags of a type
- deleteMetadataItem - Delete a metadata item
- editMetadataItem - Edit a metadata item
- detectAds - Ad-detect an item
- getAllItemLeaves - Get the leaves of an item
- analyzeMetadata - Analyze an item
- generateThumbs - Generate thumbs of chapters for an item
- detectCredits - Credit detect a metadata item
- getExtras - Get an item's extras
- addExtras - Add to an item's extras
- getFile - Get a file from a metadata or media bundle
- startBifGeneration - Start BIF generation of an item
- detectIntros - Intro detect an item
- createMarker - Create a marker
- matchItem - Match a metadata item
- listMatches - Get metadata matches for an item
- mergeItems - Merge a metadata item
- listSonicallySimilar - Get nearest tracks to metadata item
- setItemPreferences - Set metadata preferences
- refreshItemsMetadata - Refresh a metadata item
- getRelatedItems - Get related items
- listSimilar - Get similar items
- splitItem - Split a metadata item
- addSubtitles - Add subtitles
- getItemTree - Get metadata items as a tree
- unmatch - Unmatch a metadata item
- listTopUsers - Get metadata top users
- detectVoiceActivity - Detect voice activity
- getAugmentationStatus - Get augmentation status
- setStreamSelection - Set stream selection
- getPerson - Get person details
- listPersonMedia - Get media for a person
- deleteLibrarySection - Delete a library section
- getLibraryDetails - Get a library section by id
- editSection - Edit a library section
- updateItems - Set the fields of the filtered items
- startAnalysis - Analyze a section
- autocomplete - Get autocompletions for search
- getCollections - Get collections in a section
- getCommon - Get common fields for items
- emptyTrash - Empty section trash
- getSectionFilters - Get section filters
- getFirstCharacters - Get list of first characters
- deleteIndexes - Delete section indexes
- deleteIntros - Delete section intro markers
- getSectionPreferences - Get section prefs
- setSectionPreferences - Set section prefs
- cancelRefresh - Cancel section refresh
- refreshSection - Refresh section
- getAvailableSorts - Get a section sorts
- getStreamLevels - Get loudness about a stream in json
- getStreamLoudness - Get loudness about a stream
- getChapterImage - Get a chapter image
- setItemArtwork - Set an item's artwork, theme, etc
- updateItemArtwork - Set an item's artwork, theme, etc
- deleteMarker - Delete a marker
- editMarker - Edit a marker
- deleteMediaItem - Delete a media item
- getPartIndex - Get BIF index for a part
- deleteCollection - Delete a collection
- getSectionImage - Get a section composite image
- deleteStream - Delete a stream
- getStream - Get a stream
- setStreamOffset - Set a stream offset
- getItemArtwork - Get an item's artwork, theme, etc
- getMediaPart - Get a media part
- getImageFromBif - Get an image from part BIF
getLibraryItems
Request all metadata items according to a query.
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetLibraryItemsRequest;
import dev.plexapi.sdk.models.operations.GetLibraryItemsResponse;
import dev.plexapi.sdk.models.shared.*;
import java.lang.Exception;
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();
GetLibraryItemsRequest req = GetLibraryItemsRequest.builder()
.mediaQuery(MediaQuery.builder()
.type(MediaType.Episode)
.sourceType(2L)
.sort("duration:desc,index")
.build())
.build();
GetLibraryItemsResponse res = sdk.library().getLibraryItems()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetLibraryItemsRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
deleteCaches
Delete the hub caches so they are recomputed on next request
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.DeleteCachesResponse;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
DeleteCachesResponse res = sdk.library().deleteCaches()
.call();
// handle response
}
}
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
cleanBundles
Clean out any now unused bundles. Bundles can become unused when media is deleted
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.CleanBundlesResponse;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
CleanBundlesResponse res = sdk.library().cleanBundles()
.call();
// handle response
}
}
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
ingestTransientItem
This endpoint takes a file path specified in the url parameter, matches it using the scanner's match mechanism, downloads rich metadata, and then ingests the item as a transient item (without a library section). In the case where the file represents an episode, the entire tree (show, season, and episode) is added as transient items. At this time, movies and episodes are the only supported types, which are gleaned automatically from the file path.
Note that any of the parameters passed to the metadata details endpoint (e.g. includeExtras=1) work here.
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.IngestTransientItemRequest;
import dev.plexapi.sdk.models.operations.IngestTransientItemResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
IngestTransientItemRequest req = IngestTransientItemRequest.builder()
.url("file:///storage%2Femulated%2F0%2FArcher-S01E01.mkv")
.virtualFilePath("/Avatar.mkv")
.computeHashes(BoolInt.True)
.ingestNonMatches(BoolInt.True)
.build();
IngestTransientItemResponse res = sdk.library().ingestTransientItem()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
IngestTransientItemRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getLibraryMatches
The matches endpoint is used to match content external to the library with content inside the library. This is done by passing a series of semantic "hints" about the content (its type, name, or release year). Each type (e.g. movie) has a canonical set of minimal required hints.
This ability to match content is useful in a variety of scenarios. For example, in the DVR, the EPG uses the endpoint to match recording rules against airing content. And in the cloud, the UMP uses the endpoint to match up a piece of media with rich metadata.
The endpoint response can including multiple matches, if there is ambiguity, each one containing a score from 0 to 100. For somewhat historical reasons, anything over 85 is considered a positive match (we prefer false negatives over false positives in general for matching).
The guid hint is somewhat special, in that it generally represents a unique identity for a piece of media (e.g. the IMDB ttXXX) identifier, in contrast with other hints which can be much more ambiguous (e.g. a title of Jane Eyre, which could refer to the 1943 or the 2011 version).
Episodes require either a season/episode pair, or an air date (or both). Either the path must be sent, or the show title
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetLibraryMatchesRequest;
import dev.plexapi.sdk.models.operations.GetLibraryMatchesResponse;
import dev.plexapi.sdk.models.shared.*;
import java.lang.Exception;
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();
GetLibraryMatchesRequest req = GetLibraryMatchesRequest.builder()
.type(MediaType.TvShow)
.includeFullMetadata(BoolInt.True)
.includeAncestorMetadata(BoolInt.True)
.includeAlternateMetadataSources(BoolInt.True)
.build();
GetLibraryMatchesResponse res = sdk.library().getLibraryMatches()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetLibraryMatchesRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
optimizeDatabase
Initiate optimize on the database.
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.OptimizeDatabaseRequest;
import dev.plexapi.sdk.models.operations.OptimizeDatabaseResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
OptimizeDatabaseRequest req = OptimizeDatabaseRequest.builder()
.async(BoolInt.True)
.build();
OptimizeDatabaseResponse res = sdk.library().optimizeDatabase()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
OptimizeDatabaseRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getRandomArtwork
Get random artwork across sections. This is commonly used for a screensaver.
This retrieves 100 random artwork paths in the specified sections and returns them. Restrictions are put in place to not return artwork for items the user is not allowed to access. Artwork will be for Movies, Shows, and Artists only.
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetRandomArtworkRequest;
import dev.plexapi.sdk.models.operations.GetRandomArtworkResponse;
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();
GetRandomArtworkRequest req = GetRandomArtworkRequest.builder()
.sections(List.of(
5L,
6L))
.build();
GetRandomArtworkResponse res = sdk.library().getRandomArtwork()
.request(req)
.call();
if (res.mediaContainerWithArtwork().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetRandomArtworkRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getSections
A library section (commonly referred to as just a library) is a collection of media. Libraries are typed, and depending on their type provide either a flat or a hierarchical view of the media. For example, a music library has an artist > albums > tracks structure, whereas a movie library is flat. Libraries have features beyond just being a collection of media; for starters, they include information about supported types, filters and sorts. This allows a client to provide a rich interface around the media (e.g. allow sorting movies by release year).
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetSectionsResponse;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
GetSectionsResponse res = sdk.library().getSections()
.call();
if (res.object().isPresent()) {
// handle response
}
}
}
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
addSection
Add a new library section to the server
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.*;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
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();
AddSectionRequest req = AddSectionRequest.builder()
.name("<value>")
.type(39544L)
.agent("<value>")
.language("<value>")
.locations(List.of(
"O:\fatboy\\Media\\Ripped\\Music",
"O:\fatboy\\Media\\My Music"))
.prefs(QueryParamPrefs.builder()
.build())
.relative(BoolInt.True)
.importFromiTunes(BoolInt.True)
.build();
AddSectionResponse res = sdk.library().addSection()
.request(req)
.call();
if (res.slashGetResponses200().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
AddSectionRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
stopAllRefreshes
Stop all refreshes across all sections
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.StopAllRefreshesResponse;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
StopAllRefreshesResponse res = sdk.library().stopAllRefreshes()
.call();
if (res.librarySections().isPresent()) {
// handle response
}
}
}
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getSectionsPrefs
Get a section's preferences for a metadata type
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetSectionsPrefsRequest;
import dev.plexapi.sdk.models.operations.GetSectionsPrefsResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetSectionsPrefsRequest req = GetSectionsPrefsRequest.builder()
.type(460221L)
.build();
GetSectionsPrefsResponse res = sdk.library().getSectionsPrefs()
.request(req)
.call();
if (res.librarySections().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetSectionsPrefsRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
refreshSectionsMetadata
Tell PMS to refresh all section metadata
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.RefreshSectionsMetadataRequest;
import dev.plexapi.sdk.models.operations.RefreshSectionsMetadataResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
RefreshSectionsMetadataRequest req = RefreshSectionsMetadataRequest.builder()
.build();
RefreshSectionsMetadataResponse res = sdk.library().refreshSectionsMetadata()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
RefreshSectionsMetadataRequest | ✔️ | The request object to use for the request. |
Response
RefreshSectionsMetadataResponse
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getTags
Get all library tags of a type
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetTagsRequest;
import dev.plexapi.sdk.models.operations.GetTagsResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.MediaType;
import java.lang.Exception;
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();
GetTagsRequest req = GetTagsRequest.builder()
.type(MediaType.TvShow)
.build();
GetTagsResponse res = sdk.library().getTags()
.request(req)
.call();
if (res.object().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetTagsRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
deleteMetadataItem
Delete a single metadata item from the library, deleting media as well
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.DeleteMetadataItemRequest;
import dev.plexapi.sdk.models.operations.DeleteMetadataItemResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
DeleteMetadataItemRequest req = DeleteMetadataItemRequest.builder()
.ids("<value>")
.proxy(BoolInt.True)
.build();
DeleteMetadataItemResponse res = sdk.library().deleteMetadataItem()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
DeleteMetadataItemRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
editMetadataItem
Edit metadata items setting fields
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.EditMetadataItemRequest;
import dev.plexapi.sdk.models.operations.EditMetadataItemResponse;
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();
EditMetadataItemRequest req = EditMetadataItemRequest.builder()
.ids(List.of(
"<value 1>",
"<value 2>"))
.build();
EditMetadataItemResponse res = sdk.library().editMetadataItem()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
EditMetadataItemRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
detectAds
Start the detection of ads in a metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.DetectAdsRequest;
import dev.plexapi.sdk.models.operations.DetectAdsResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
DetectAdsRequest req = DetectAdsRequest.builder()
.ids("<value>")
.build();
DetectAdsResponse res = sdk.library().detectAds()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
DetectAdsRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getAllItemLeaves
Get the leaves for a metadata item such as the episodes in a show
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetAllItemLeavesRequest;
import dev.plexapi.sdk.models.operations.GetAllItemLeavesResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetAllItemLeavesRequest req = GetAllItemLeavesRequest.builder()
.ids("<value>")
.build();
GetAllItemLeavesResponse res = sdk.library().getAllItemLeaves()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetAllItemLeavesRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
analyzeMetadata
Start the analysis of a metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.AnalyzeMetadataRequest;
import dev.plexapi.sdk.models.operations.AnalyzeMetadataResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
AnalyzeMetadataRequest req = AnalyzeMetadataRequest.builder()
.ids("<value>")
.build();
AnalyzeMetadataResponse res = sdk.library().analyzeMetadata()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
AnalyzeMetadataRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
generateThumbs
Start the chapter thumb generation for an item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GenerateThumbsRequest;
import dev.plexapi.sdk.models.operations.GenerateThumbsResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
GenerateThumbsRequest req = GenerateThumbsRequest.builder()
.ids("<value>")
.force(BoolInt.True)
.build();
GenerateThumbsResponse res = sdk.library().generateThumbs()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GenerateThumbsRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
detectCredits
Start credit detection on a metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.DetectCreditsRequest;
import dev.plexapi.sdk.models.operations.DetectCreditsResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
DetectCreditsRequest req = DetectCreditsRequest.builder()
.ids("<value>")
.force(BoolInt.True)
.manual(BoolInt.True)
.build();
DetectCreditsResponse res = sdk.library().detectCredits()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
DetectCreditsRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getExtras
Get the extras for a metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetExtrasRequest;
import dev.plexapi.sdk.models.operations.GetExtrasResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetExtrasRequest req = GetExtrasRequest.builder()
.ids("<value>")
.build();
GetExtrasResponse res = sdk.library().getExtras()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetExtrasRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
addExtras
Add an extra to a metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.AddExtrasRequest;
import dev.plexapi.sdk.models.operations.AddExtrasResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
AddExtrasRequest req = AddExtrasRequest.builder()
.ids("<value>")
.url("https://super-mortise.biz/")
.build();
AddExtrasResponse res = sdk.library().addExtras()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
AddExtrasRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getFile
Get a bundle file for a metadata or media item. This is either an image or a mp3 (for a show's theme)
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetFileRequest;
import dev.plexapi.sdk.models.operations.GetFileResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetFileRequest req = GetFileRequest.builder()
.ids("<value>")
.build();
GetFileResponse res = sdk.library().getFile()
.request(req)
.call();
if (res.twoHundredAudioMpeg3ResponseStream().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetFileRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
startBifGeneration
Start the indexing (BIF generation) of an item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.StartBifGenerationRequest;
import dev.plexapi.sdk.models.operations.StartBifGenerationResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
StartBifGenerationRequest req = StartBifGenerationRequest.builder()
.ids("<value>")
.force(BoolInt.True)
.build();
StartBifGenerationResponse res = sdk.library().startBifGeneration()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
StartBifGenerationRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
detectIntros
Start the detection of intros in a metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.DetectIntrosRequest;
import dev.plexapi.sdk.models.operations.DetectIntrosResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
DetectIntrosRequest req = DetectIntrosRequest.builder()
.ids("<value>")
.force(BoolInt.True)
.build();
DetectIntrosResponse res = sdk.library().detectIntros()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
DetectIntrosRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
createMarker
Create a marker for this user on the metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.*;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
CreateMarkerRequest req = CreateMarkerRequest.builder()
.ids("<value>")
.type(248391L)
.startTimeOffset(535191L)
.attributes(Attributes.builder()
.build())
.build();
CreateMarkerResponse res = sdk.library().createMarker()
.request(req)
.call();
if (res.object().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
CreateMarkerRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
matchItem
Match a metadata item to a guid
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.MatchItemRequest;
import dev.plexapi.sdk.models.operations.MatchItemResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
MatchItemRequest req = MatchItemRequest.builder()
.ids("<value>")
.build();
MatchItemResponse res = sdk.library().matchItem()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
MatchItemRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
listMatches
Get the list of metadata matches for a metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.ListMatchesRequest;
import dev.plexapi.sdk.models.operations.ListMatchesResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
ListMatchesRequest req = ListMatchesRequest.builder()
.ids("<value>")
.manual(BoolInt.True)
.build();
ListMatchesResponse res = sdk.library().listMatches()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
ListMatchesRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
mergeItems
Merge a metadata item with other items
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.MergeItemsRequest;
import dev.plexapi.sdk.models.operations.MergeItemsResponse;
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();
MergeItemsRequest req = MergeItemsRequest.builder()
.idsPathParameter("<value>")
.idsQueryParameter(List.of(
"<",
"v",
"a",
"l",
"u",
"e",
">"))
.build();
MergeItemsResponse res = sdk.library().mergeItems()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
MergeItemsRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
listSonicallySimilar
Get the nearest tracks, sonically, to the provided track
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.ListSonicallySimilarRequest;
import dev.plexapi.sdk.models.operations.ListSonicallySimilarResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
ListSonicallySimilarRequest req = ListSonicallySimilarRequest.builder()
.ids("<value>")
.build();
ListSonicallySimilarResponse res = sdk.library().listSonicallySimilar()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
ListSonicallySimilarRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
setItemPreferences
Set the preferences on a metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.SetItemPreferencesRequest;
import dev.plexapi.sdk.models.operations.SetItemPreferencesResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
SetItemPreferencesRequest req = SetItemPreferencesRequest.builder()
.ids("<value>")
.build();
SetItemPreferencesResponse res = sdk.library().setItemPreferences()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
SetItemPreferencesRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
refreshItemsMetadata
Refresh a metadata item from the agent
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.RefreshItemsMetadataRequest;
import dev.plexapi.sdk.models.operations.RefreshItemsMetadataResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
RefreshItemsMetadataRequest req = RefreshItemsMetadataRequest.builder()
.ids("<value>")
.markUpdated(BoolInt.True)
.build();
RefreshItemsMetadataResponse res = sdk.library().refreshItemsMetadata()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
RefreshItemsMetadataRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getRelatedItems
Get a hub of related items to a metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetRelatedItemsRequest;
import dev.plexapi.sdk.models.operations.GetRelatedItemsResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetRelatedItemsRequest req = GetRelatedItemsRequest.builder()
.ids("<value>")
.build();
GetRelatedItemsResponse res = sdk.library().getRelatedItems()
.request(req)
.call();
if (res.object().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetRelatedItemsRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
listSimilar
Get a list of similar items to a metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.ListSimilarRequest;
import dev.plexapi.sdk.models.operations.ListSimilarResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
ListSimilarRequest req = ListSimilarRequest.builder()
.ids("<value>")
.build();
ListSimilarResponse res = sdk.library().listSimilar()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
ListSimilarRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
splitItem
Split a metadata item into multiple items
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.SplitItemRequest;
import dev.plexapi.sdk.models.operations.SplitItemResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
SplitItemRequest req = SplitItemRequest.builder()
.ids("<value>")
.build();
SplitItemResponse res = sdk.library().splitItem()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
SplitItemRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
addSubtitles
Add a subtitle to a metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.AddSubtitlesRequest;
import dev.plexapi.sdk.models.operations.AddSubtitlesResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
AddSubtitlesRequest req = AddSubtitlesRequest.builder()
.ids("<value>")
.forced(BoolInt.True)
.hearingImpaired(BoolInt.True)
.build();
AddSubtitlesResponse res = sdk.library().addSubtitles()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
AddSubtitlesRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getItemTree
Get a tree of metadata items, such as the seasons/episodes of a show
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetItemTreeRequest;
import dev.plexapi.sdk.models.operations.GetItemTreeResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetItemTreeRequest req = GetItemTreeRequest.builder()
.ids("<value>")
.build();
GetItemTreeResponse res = sdk.library().getItemTree()
.request(req)
.call();
if (res.mediaContainerWithNestedMetadata().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetItemTreeRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
unmatch
Unmatch a metadata item to info fetched from the agent
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.UnmatchRequest;
import dev.plexapi.sdk.models.operations.UnmatchResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
UnmatchRequest req = UnmatchRequest.builder()
.ids("<value>")
.build();
UnmatchResponse res = sdk.library().unmatch()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
UnmatchRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
listTopUsers
Get the list of users which have played this item starting with the most
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.ListTopUsersRequest;
import dev.plexapi.sdk.models.operations.ListTopUsersResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
ListTopUsersRequest req = ListTopUsersRequest.builder()
.ids("<value>")
.build();
ListTopUsersResponse res = sdk.library().listTopUsers()
.request(req)
.call();
if (res.object().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
ListTopUsersRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
detectVoiceActivity
Start the detection of voice in a metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.DetectVoiceActivityRequest;
import dev.plexapi.sdk.models.operations.DetectVoiceActivityResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
DetectVoiceActivityRequest req = DetectVoiceActivityRequest.builder()
.ids("<value>")
.force(BoolInt.True)
.manual(BoolInt.True)
.build();
DetectVoiceActivityResponse res = sdk.library().detectVoiceActivity()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
DetectVoiceActivityRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getAugmentationStatus
Get augmentation status and potentially wait for completion
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetAugmentationStatusRequest;
import dev.plexapi.sdk.models.operations.GetAugmentationStatusResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
GetAugmentationStatusRequest req = GetAugmentationStatusRequest.builder()
.augmentationId("<id>")
.wait_(BoolInt.True)
.build();
GetAugmentationStatusResponse res = sdk.library().getAugmentationStatus()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetAugmentationStatusRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
setStreamSelection
Set which streams (audio/subtitle) are selected by this user
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.SetStreamSelectionRequest;
import dev.plexapi.sdk.models.operations.SetStreamSelectionResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
SetStreamSelectionRequest req = SetStreamSelectionRequest.builder()
.partId(360489L)
.allParts(BoolInt.True)
.build();
SetStreamSelectionResponse res = sdk.library().setStreamSelection()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
SetStreamSelectionRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getPerson
Get details for a single actor.
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetPersonRequest;
import dev.plexapi.sdk.models.operations.GetPersonResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetPersonRequest req = GetPersonRequest.builder()
.personId("<id>")
.build();
GetPersonResponse res = sdk.library().getPerson()
.request(req)
.call();
if (res.object().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetPersonRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
listPersonMedia
Get all the media for a single actor.
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.ListPersonMediaRequest;
import dev.plexapi.sdk.models.operations.ListPersonMediaResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
ListPersonMediaRequest req = ListPersonMediaRequest.builder()
.personId("<id>")
.build();
ListPersonMediaResponse res = sdk.library().listPersonMedia()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
ListPersonMediaRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
deleteLibrarySection
Delete a library section by id
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.DeleteLibrarySectionRequest;
import dev.plexapi.sdk.models.operations.DeleteLibrarySectionResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
DeleteLibrarySectionRequest req = DeleteLibrarySectionRequest.builder()
.sectionId("<id>")
.async(BoolInt.True)
.build();
DeleteLibrarySectionResponse res = sdk.library().deleteLibrarySection()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
DeleteLibrarySectionRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getLibraryDetails
Returns details for the library. This can be thought of as an interstitial endpoint because it contains information about the library, rather than content itself. It often contains a list of Directory metadata objects: These used to be used by clients to build a menuing system.
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetLibraryDetailsRequest;
import dev.plexapi.sdk.models.operations.GetLibraryDetailsResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
GetLibraryDetailsRequest req = GetLibraryDetailsRequest.builder()
.sectionId("<id>")
.includeDetails(BoolInt.True)
.build();
GetLibraryDetailsResponse res = sdk.library().getLibraryDetails()
.request(req)
.call();
if (res.object().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetLibraryDetailsRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
editSection
Edit a library section by id setting parameters
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.*;
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();
EditSectionRequest req = EditSectionRequest.builder()
.sectionId("<id>")
.agent("<value>")
.locations(List.of(
"O:\fatboy\\Media\\Ripped\\Music",
"O:\fatboy\\Media\\My Music"))
.prefs(EditSectionQueryParamPrefs.builder()
.build())
.build();
EditSectionResponse res = sdk.library().editSection()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
EditSectionRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
updateItems
This endpoint takes an large possible set of values. Here are some examples.
-
Parameters, extra documentation
- artist.title.value
- When used with track, both artist.title.value and album.title.value need to be specified
- title.value usage
- Summary
- Tracks always rename and never merge
- Albums and Artists
- if single item and item without title does not exist, it is renamed.
- if single item and item with title does exist they are merged.
- if multiple they are always merged.
- Tracks
- Works as expected will update the track's title
- Single track:
/library/sections/{id}/all?type=10&id=42&title.value=NewName - Multiple tracks:
/library/sections/{id}/all?type=10&id=42,43,44&title.value=NewName - All tracks:
/library/sections/{id}/all?type=10&title.value=NewName
- Albums
- Functionality changes depending on the existence of an album with the same title
- Album exists
- Single album:
/library/sections/{id}/all?type=9&id=42&title.value=Album 2- Album with id 42 is merged into album titled "Album 2"
- Multiple/All albums:
/library/sections/{id}/all?type=9&title.value=Moo Album- All albums are merged into the existing album titled "Moo Album"
- Single album:
- Album does not exist
- Single album:
/library/sections/{id}/all?type=9&id=42&title.value=NewAlbumTitle- Album with id 42 has title modified to "NewAlbumTitle"
- Multiple/All albums:
/library/sections/{id}/all?type=9&title.value=NewAlbumTitle- All albums are merged into a new album with title="NewAlbumTitle"
- Single album:
- Artists
- Functionaly changes depending on the existence of an artist with the same title.
- Artist exists
- Single artist:
/library/sections/{id}/all?type=8&id=42&title.value=Artist 2- Artist with id 42 is merged into existing artist titled "Artist 2"
- Multiple/All artists:
/library/sections/{id}/all?type=8&title.value=Artist 3- All artists are merged into the existing artist titled "Artist 3"
- Single artist:
- Artist does not exist
- Single artist:
/library/sections/{id}/all?type=8&id=42&title.value=NewArtistTitle- Artist with id 42 has title modified to "NewArtistTitle"
- Multiple/All artists:
/library/sections/{id}/all?type=8&title.value=NewArtistTitle- All artists are merged into a new artist with title="NewArtistTitle"
- Single artist:
- Summary
- artist.title.value
-
Notes
- Technically square brackets are not allowed in an URI except the Internet Protocol Literal Address
- RFC3513: A host identified by an Internet Protocol literal address, version 6 [RFC3513] or later, is distinguished by enclosing the IP literal within square brackets ("[" and "]"). This is the only place where square bracket characters are allowed in the URI syntax.
- Escaped square brackets are allowed, but don't render well
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.UpdateItemsRequest;
import dev.plexapi.sdk.models.operations.UpdateItemsResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
UpdateItemsRequest req = UpdateItemsRequest.builder()
.sectionId("<id>")
.fieldLocked(BoolInt.True)
.build();
UpdateItemsResponse res = sdk.library().updateItems()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
UpdateItemsRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
startAnalysis
Start analysis of all items in a section. If BIF generation is enabled, this will also be started on this section
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.StartAnalysisRequest;
import dev.plexapi.sdk.models.operations.StartAnalysisResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
StartAnalysisRequest req = StartAnalysisRequest.builder()
.sectionId(158829L)
.build();
StartAnalysisResponse res = sdk.library().startAnalysis()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
StartAnalysisRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
autocomplete
The field to autocomplete on is specified by the {field}.query parameter. For example genre.query or title.query.
Returns a set of items from the filtered items whose {field} starts with {field}.query. In the results, a {field}.queryRange will be present to express the range of the match
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.AutocompleteRequest;
import dev.plexapi.sdk.models.operations.AutocompleteResponse;
import dev.plexapi.sdk.models.shared.*;
import java.lang.Exception;
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();
AutocompleteRequest req = AutocompleteRequest.builder()
.sectionId(942007L)
.mediaQuery(MediaQuery.builder()
.type(MediaType.Episode)
.sourceType(2L)
.sort("duration:desc,index")
.build())
.build();
AutocompleteResponse res = sdk.library().autocomplete()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
AutocompleteRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getCollections
Get all collections in a section
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetCollectionsRequest;
import dev.plexapi.sdk.models.operations.GetCollectionsResponse;
import dev.plexapi.sdk.models.shared.*;
import java.lang.Exception;
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();
GetCollectionsRequest req = GetCollectionsRequest.builder()
.sectionId(348838L)
.mediaQuery(MediaQuery.builder()
.type(MediaType.Episode)
.sourceType(2L)
.sort("duration:desc,index")
.build())
.build();
GetCollectionsResponse res = sdk.library().getCollections()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetCollectionsRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getCommon
Represents a "Common" item. It contains only the common attributes of the items selected by the provided filter
Fields which are not common will be expressed in the mixedFields field
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetCommonRequest;
import dev.plexapi.sdk.models.operations.GetCommonResponse;
import dev.plexapi.sdk.models.shared.*;
import java.lang.Exception;
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();
GetCommonRequest req = GetCommonRequest.builder()
.sectionId(298154L)
.mediaQuery(MediaQuery.builder()
.type(MediaType.Episode)
.sourceType(2L)
.sort("duration:desc,index")
.build())
.build();
GetCommonResponse res = sdk.library().getCommon()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetCommonRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
emptyTrash
Empty trash in the section, permanently deleting media/metadata for missing media
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.EmptyTrashRequest;
import dev.plexapi.sdk.models.operations.EmptyTrashResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
EmptyTrashRequest req = EmptyTrashRequest.builder()
.sectionId(30052L)
.build();
EmptyTrashResponse res = sdk.library().emptyTrash()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
EmptyTrashRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getSectionFilters
Get common filters on a section
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetSectionFiltersRequest;
import dev.plexapi.sdk.models.operations.GetSectionFiltersResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetSectionFiltersRequest req = GetSectionFiltersRequest.builder()
.sectionId(380557L)
.build();
GetSectionFiltersResponse res = sdk.library().getSectionFilters()
.request(req)
.call();
if (res.object().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetSectionFiltersRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getFirstCharacters
Get list of first characters in this section
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetFirstCharactersRequest;
import dev.plexapi.sdk.models.operations.GetFirstCharactersResponse;
import dev.plexapi.sdk.models.shared.*;
import java.lang.Exception;
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();
GetFirstCharactersRequest req = GetFirstCharactersRequest.builder()
.sectionId(3947L)
.mediaQuery(MediaQuery.builder()
.type(MediaType.Episode)
.sourceType(2L)
.sort("duration:desc,index")
.build())
.build();
GetFirstCharactersResponse res = sdk.library().getFirstCharacters()
.request(req)
.call();
if (res.object().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetFirstCharactersRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
deleteIndexes
Delete all the indexes in a section
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.DeleteIndexesRequest;
import dev.plexapi.sdk.models.operations.DeleteIndexesResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
DeleteIndexesRequest req = DeleteIndexesRequest.builder()
.sectionId(588437L)
.build();
DeleteIndexesResponse res = sdk.library().deleteIndexes()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
DeleteIndexesRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
deleteIntros
Delete all the intro markers in a section
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.DeleteIntrosRequest;
import dev.plexapi.sdk.models.operations.DeleteIntrosResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
DeleteIntrosRequest req = DeleteIntrosRequest.builder()
.sectionId(498656L)
.build();
DeleteIntrosResponse res = sdk.library().deleteIntros()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
DeleteIntrosRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getSectionPreferences
Get the prefs for a section by id and potentially overriding the agent
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetSectionPreferencesRequest;
import dev.plexapi.sdk.models.operations.GetSectionPreferencesResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetSectionPreferencesRequest req = GetSectionPreferencesRequest.builder()
.sectionId(754869L)
.build();
GetSectionPreferencesResponse res = sdk.library().getSectionPreferences()
.request(req)
.call();
if (res.mediaContainerWithSettings().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetSectionPreferencesRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
setSectionPreferences
Set the prefs for a section by id
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.*;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
SetSectionPreferencesRequest req = SetSectionPreferencesRequest.builder()
.sectionId(349936L)
.prefs(SetSectionPreferencesQueryParamPrefs.builder()
.build())
.build();
SetSectionPreferencesResponse res = sdk.library().setSectionPreferences()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
SetSectionPreferencesRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
cancelRefresh
Cancel the refresh of a section
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.CancelRefreshRequest;
import dev.plexapi.sdk.models.operations.CancelRefreshResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
CancelRefreshRequest req = CancelRefreshRequest.builder()
.sectionId(326852L)
.build();
CancelRefreshResponse res = sdk.library().cancelRefresh()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
CancelRefreshRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
refreshSection
Start a refresh of this section
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.RefreshSectionRequest;
import dev.plexapi.sdk.models.operations.RefreshSectionResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
RefreshSectionRequest req = RefreshSectionRequest.builder()
.sectionId(450300L)
.force(BoolInt.True)
.build();
RefreshSectionResponse res = sdk.library().refreshSection()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
RefreshSectionRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getAvailableSorts
Get the sort mechanisms available in a section
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetAvailableSortsRequest;
import dev.plexapi.sdk.models.operations.GetAvailableSortsResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetAvailableSortsRequest req = GetAvailableSortsRequest.builder()
.sectionId(212498L)
.build();
GetAvailableSortsResponse res = sdk.library().getAvailableSorts()
.request(req)
.call();
if (res.object().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetAvailableSortsRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getStreamLevels
The the loudness of a stream in db, one entry per 100ms
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetStreamLevelsRequest;
import dev.plexapi.sdk.models.operations.GetStreamLevelsResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetStreamLevelsRequest req = GetStreamLevelsRequest.builder()
.streamId(447611L)
.build();
GetStreamLevelsResponse res = sdk.library().getStreamLevels()
.request(req)
.call();
if (res.object().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetStreamLevelsRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getStreamLoudness
The the loudness of a stream in db, one number per line, one entry per 100ms
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetStreamLoudnessRequest;
import dev.plexapi.sdk.models.operations.GetStreamLoudnessResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetStreamLoudnessRequest req = GetStreamLoudnessRequest.builder()
.streamId(277271L)
.build();
GetStreamLoudnessResponse res = sdk.library().getStreamLoudness()
.request(req)
.call();
if (res.res().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetStreamLoudnessRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getChapterImage
Get a single chapter image for a piece of media
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetChapterImageRequest;
import dev.plexapi.sdk.models.operations.GetChapterImageResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetChapterImageRequest req = GetChapterImageRequest.builder()
.mediaId(892563L)
.chapter(48348L)
.build();
GetChapterImageResponse res = sdk.library().getChapterImage()
.request(req)
.call();
if (res.responseStream().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetChapterImageRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
setItemArtwork
Set the artwork, thumb, element for a metadata item Generally only the admin can perform this action. The exception is if the metadata is a playlist created by the user
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.*;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
SetItemArtworkRequest req = SetItemArtworkRequest.builder()
.ids("<value>")
.element(Element.BANNER)
.build();
SetItemArtworkResponse res = sdk.library().setItemArtwork()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
SetItemArtworkRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
updateItemArtwork
Set the artwork, thumb, element for a metadata item Generally only the admin can perform this action. The exception is if the metadata is a playlist created by the user
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.*;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
UpdateItemArtworkRequest req = UpdateItemArtworkRequest.builder()
.ids("<value>")
.element(PathParamElement.CLEAR_LOGO)
.build();
UpdateItemArtworkResponse res = sdk.library().updateItemArtwork()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
UpdateItemArtworkRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
deleteMarker
Delete a marker for this user on the metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.DeleteMarkerRequest;
import dev.plexapi.sdk.models.operations.DeleteMarkerResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
DeleteMarkerRequest req = DeleteMarkerRequest.builder()
.ids("<value>")
.marker("<value>")
.build();
DeleteMarkerResponse res = sdk.library().deleteMarker()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
DeleteMarkerRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
editMarker
Edit a marker for this user on the metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.*;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
EditMarkerRequest req = EditMarkerRequest.builder()
.ids("<value>")
.marker("<value>")
.type(884347L)
.startTimeOffset(517251L)
.attributes(QueryParamAttributes.builder()
.build())
.build();
EditMarkerResponse res = sdk.library().editMarker()
.request(req)
.call();
if (res.postResponses200().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
EditMarkerRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
deleteMediaItem
Delete a single media from a metadata item in the library
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.DeleteMediaItemRequest;
import dev.plexapi.sdk.models.operations.DeleteMediaItemResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
DeleteMediaItemRequest req = DeleteMediaItemRequest.builder()
.ids("<value>")
.mediaItem("<value>")
.proxy(BoolInt.True)
.build();
DeleteMediaItemResponse res = sdk.library().deleteMediaItem()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
DeleteMediaItemRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getPartIndex
Get BIF index for a part by index type
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.*;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetPartIndexRequest req = GetPartIndexRequest.builder()
.partId(724750L)
.index(Index.SD)
.build();
GetPartIndexResponse res = sdk.library().getPartIndex()
.request(req)
.call();
if (res.responseStream().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetPartIndexRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
deleteCollection
Delete a library collection from the PMS
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.DeleteCollectionRequest;
import dev.plexapi.sdk.models.operations.DeleteCollectionResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
DeleteCollectionRequest req = DeleteCollectionRequest.builder()
.sectionId(283619L)
.collectionId(680895L)
.build();
DeleteCollectionResponse res = sdk.library().deleteCollection()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
DeleteCollectionRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getSectionImage
Get a composite image of images in this section
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetSectionImageRequest;
import dev.plexapi.sdk.models.operations.GetSectionImageResponse;
import dev.plexapi.sdk.models.shared.*;
import java.lang.Exception;
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();
GetSectionImageRequest req = GetSectionImageRequest.builder()
.sectionId(925611L)
.updatedAt(117413L)
.mediaQuery(MediaQuery.builder()
.type(MediaType.Episode)
.sourceType(2L)
.sort("duration:desc,index")
.build())
.build();
GetSectionImageResponse res = sdk.library().getSectionImage()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetSectionImageRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
deleteStream
Delete a stream. Only applies to downloaded subtitle streams or a sidecar subtitle when media deletion is enabled.
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.DeleteStreamRequest;
import dev.plexapi.sdk.models.operations.DeleteStreamResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
DeleteStreamRequest req = DeleteStreamRequest.builder()
.streamId(841510L)
.ext("<value>")
.build();
DeleteStreamResponse res = sdk.library().deleteStream()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
DeleteStreamRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getStream
Get a stream (such as a sidecar subtitle stream)
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetStreamRequest;
import dev.plexapi.sdk.models.operations.GetStreamResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
GetStreamRequest req = GetStreamRequest.builder()
.streamId(314506L)
.ext("<value>")
.autoAdjustSubtitle(BoolInt.True)
.build();
GetStreamResponse res = sdk.library().getStream()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetStreamRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
setStreamOffset
Set a stream offset in ms. This may not be respected by all clients
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.SetStreamOffsetRequest;
import dev.plexapi.sdk.models.operations.SetStreamOffsetResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
SetStreamOffsetRequest req = SetStreamOffsetRequest.builder()
.streamId(606295L)
.ext("<value>")
.build();
SetStreamOffsetResponse res = sdk.library().setStreamOffset()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
SetStreamOffsetRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getItemArtwork
Get the artwork, thumb, element for a metadata item
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.*;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetItemArtworkRequest req = GetItemArtworkRequest.builder()
.ids("<value>")
.element(GetItemArtworkPathParamElement.POSTER)
.timestamp(999555L)
.build();
GetItemArtworkResponse res = sdk.library().getItemArtwork()
.request(req)
.call();
if (res.twoHundredAudioMpeg3ResponseStream().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetItemArtworkRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getMediaPart
Get a media part for streaming or download.
- streaming: This is the default scenario. Bandwidth usage on this endpoint will be guaranteed (on the server's end) to be at least the bandwidth reservation given in the decision. If no decision exists, an ad-hoc decision will be created if sufficient bandwidth exists. Clients should not rely on ad-hoc decisions being made as this may be removed in the future.
- download: Indicated if the query parameter indicates this is a download. Bandwidth will be prioritized behind playbacks and will get a fair share of what remains.
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetMediaPartRequest;
import dev.plexapi.sdk.models.operations.GetMediaPartResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
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();
GetMediaPartRequest req = GetMediaPartRequest.builder()
.partId(877105L)
.changestamp(970622L)
.filename("example.file")
.download(BoolInt.True)
.build();
GetMediaPartResponse res = sdk.library().getMediaPart()
.request(req)
.call();
// handle response
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetMediaPartRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |
getImageFromBif
Extract an image from the BIF for a part at a particular offset
Example Usage
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.*;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
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();
GetImageFromBifRequest req = GetImageFromBifRequest.builder()
.partId(304273L)
.index(PathParamIndex.SD)
.offset(939569L)
.build();
GetImageFromBifResponse res = sdk.library().getImageFromBif()
.request(req)
.call();
if (res.responseStream().isPresent()) {
// handle response
}
}
}
Parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
request |
GetImageFromBifRequest | ✔️ | The request object to use for the request. |
Response
Errors
| Error Type | Status Code | Content Type |
|---|---|---|
| models/errors/SDKError | 4XX, 5XX | */* |