SDKs overview

Pocket offers an API primarily designed for third-party applications to interact with a user's saved items. This includes functionalities such as adding new articles, retrieving existing ones, and managing their status (e.g., archiving, favoriting, deleting). Access to the Pocket API requires obtaining a consumer key and implementing OAuth 2.0 for user authorization, which grants your application permission to access a user's Pocket account. While Pocket maintains an official API, direct official SDKs provided by Pocket are limited; however, a robust ecosystem of community-developed libraries exists to facilitate integration across various programming languages. These libraries often handle the complexities of OAuth authentication, API request formatting, and response parsing, allowing developers to focus on application-specific logic.

The core operations supported by the Pocket API, and consequently by its SDKs and libraries, revolve around two main endpoints: the Add API and the Retrieve API. The Add API allows applications to save URLs to a user's Pocket list, while the Retrieve API enables fetching items based on various criteria such as status, tags, and content type. Understanding these fundamental API interactions is key to utilizing any Pocket SDK or library effectively.

Official SDKs by language

As of 2026, Pocket does not provide a comprehensive suite of officially maintained SDKs across multiple programming languages in the traditional sense, such as those offered by platforms like Stripe's SDKs or Google Cloud Client Libraries. The primary official resource for developers is the Pocket API documentation itself, which details the RESTful endpoints and authentication flow. Developers are generally expected to interact with the API directly or utilize community-contributed libraries. However, Pocket does provide a foundational Python library to interact with its API, which serves as a reference and a practical tool for Python developers.

Language Package/Repository Install Command Maturity
Python pocket (maintained by Pocket) pip install pocket Stable

Installation

Installation procedures for Pocket-related libraries typically follow the standard package management practices of their respective programming languages. For the official Python library, the process is straightforward using pip, Python's package installer. Community libraries will have similar installation instructions, usually involving their language's primary package manager.

Python (Official Library)

To install the official Pocket Python library, open your terminal or command prompt and execute the following command:

pip install pocket

This command downloads and installs the library and its dependencies, making the pocket module available for import in your Python projects. Ensure you have Python and pip installed on your system before attempting this.

Other Languages (Community Libraries)

For community-developed libraries in other languages, the installation will vary. For example:

  • JavaScript/Node.js: Typically installed via npm (npm install <library-name>) or yarn (yarn add <library-name>).
  • PHP: Usually installed via Composer (composer require <vendor>/<package>).
  • Ruby: Installed via RubyGems (gem install <gem-name>).
  • Go: Managed with Go modules (go get <module-path>).

Always refer to the specific library's documentation or GitHub repository for precise and up-to-date installation instructions.

Quickstart example

This quickstart demonstrates how to use the official Python Pocket library to authenticate and add a URL to a user's Pocket list. Before running this code, you will need a Pocket Consumer Key, which can be obtained by registering your application with Pocket. The authentication flow involves redirecting the user to Pocket for authorization and then exchanging a request token for an access token.

from pocket import Pocket, PocketException
import webbrowser
import time

# --- Configuration --- #
CONSUMER_KEY = "YOUR_CONSUMER_KEY" # Replace with your actual Consumer Key
REDIRECT_URI = "http://localhost:8000/callback" # Must match the redirect URI configured for your app

# --- Step 1: Obtain a Request Token --- #
def get_request_token():
    try:
        pocket_instance = Pocket(consumer_key=CONSUMER_KEY, redirect_uri=REDIRECT_URI)
        request_token = pocket_instance.get_request_token()
        print(f"Request Token: {request_token}")
        return request_token, pocket_instance
    except PocketException as e:
        print(f"Error getting request token: {e}")
        return None, None

# --- Step 2: Authorize the Request Token --- #
def authorize_request_token(request_token, pocket_instance):
    auth_url = pocket_instance.get_auth_url(request_token)
    print(f"Please open this URL in your browser to authorize Pocket: {auth_url}")
    webbrowser.open(auth_url)
    print("Waiting for user authorization... Press Enter after authorizing in browser.")
    input()

# --- Step 3: Obtain an Access Token --- #
def get_access_token(request_token, pocket_instance):
    try:
        user_auth = pocket_instance.get_access_token(request_token)
        access_token = user_auth['access_token']
        username = user_auth['username']
        print(f"Access Token: {access_token}")
        print(f"Authorized User: {username}")
        return access_token, username
    except PocketException as e:
        print(f"Error getting access token: {e}")
        return None, None

# --- Step 4: Use the Access Token to Add an Item --- #
def add_item_to_pocket(consumer_key, access_token, url, title=None, tags=None):
    try:
        pocket_instance = Pocket(consumer_key=consumer_key, access_token=access_token)
        item_data = pocket_instance.add(url=url, title=title, tags=tags)
        print(f"Successfully added item: {item_data['item']['resolved_title'] or item_data['item']['given_title']}")
        print(f"URL: {item_data['item']['resolved_url'] or item_data['item']['given_url']}")
    except PocketException as e:
        print(f"Error adding item: {e}")

# --- Main Execution Flow --- #
if __name__ == "__main__":
    request_token, pocket_instance = get_request_token()
    if request_token:
        authorize_request_token(request_token, pocket_instance)
        access_token, username = get_access_token(request_token, pocket_instance)
        if access_token:
            # Example: Add an article
            target_url = "https://www.apispine.com/blog/api-design-patterns"
            target_title = "API Design Patterns"
            target_tags = "api,development,patterns"
            add_item_to_pocket(CONSUMER_KEY, access_token, target_url, target_title, target_tags)
        else:
            print("Failed to obtain access token. Exiting.")
    else:
        print("Failed to obtain request token. Exiting.")

To run this example:

  1. Install the Pocket Python library: pip install pocket.
  2. Replace YOUR_CONSUMER_KEY with your actual Pocket Consumer Key.
  3. Ensure the REDIRECT_URI matches the one configured for your application in Pocket's developer settings.
  4. Execute the script. It will open a browser for authorization and prompt you to press Enter after completion.

This script demonstrates the full OAuth flow required for a desktop or web application to gain authorized access to a user's Pocket account and perform an 'add' operation. For server-side applications, the redirect URI and user interaction might be handled differently, potentially involving a web server to catch the callback.

Community libraries

Given the limited number of official SDKs, the Pocket developer community has contributed several libraries across various programming languages. These libraries often wrap the Pocket API, providing idiomatic interfaces and handling common tasks like OAuth authentication and JSON parsing. While not officially supported by Pocket, many of these libraries are well-maintained and widely used.

Developers should evaluate community libraries based on their activity, documentation quality, and compatibility with the latest Pocket API specifications. Checking the library's GitHub repository for recent commits, open issues, and pull requests can provide insight into its maintenance status.

Examples of community-contributed libraries include:

  • JavaScript/Node.js: Various npm packages exist that abstract the Pocket API, allowing integration into web applications and Node.js backends. These often focus on simplifying the OAuth flow and providing methods for adding, retrieving, and modifying items.
  • PHP: Libraries are available for PHP developers to integrate Pocket into server-side applications, often leveraging Composer for dependency management. These typically provide classes for handling authentication and API requests.
  • Ruby: Ruby Gems can be found that offer a Ruby-friendly interface to the Pocket API, making it easier for Ruby on Rails or other Ruby applications to interact with Pocket.
  • Go: Go modules are available for developers working with Go, providing structured access to Pocket's functionalities.

When selecting a community library, it's advisable to:

  • Check the documentation: Ensure it's comprehensive and includes examples.
  • Review the license: Confirm it's compatible with your project's licensing requirements.
  • Examine the codebase: Look for clean code, good test coverage, and adherence to best practices.
  • Verify API version compatibility: Ensure the library is designed for the current version of the Pocket API to avoid compatibility issues.

For the most current list and details, searching respective package managers (e.g., npm, Packagist, RubyGems) or GitHub with terms like "Pocket API," "Pocket SDK," or "Pocket client" is recommended.