canonical: https://jentic.com/apis/getpocket.com/getpocket

# Getpocket Pocket API

Jentic publishes the only available OpenAPI specification for Pocket API, keeping it validated and agent-ready. Pocket is a read-it-later service that lets users save articles, videos, and links to a personal queue for offline reading and later review. The v3 HTTP API exposes seven endpoints covering item ingestion, batch modifications, retrieval with filters and tags, OAuth handshake, tag listing, and account-level statistics. It is the canonical integration surface for browser extensions, recommendation pipelines, and reading-list automation that needs a stable, long-lived saved-item store.

## For AI agents

Save URLs to a user's Pocket queue, retrieve saved items by tag or state, and apply batch tag and archive operations through OAuth-scoped access tokens.

## Scope

Does not handle full-text content extraction, recommendation, or social sharing - use for managing a user's saved-item queue and tags only.

## Capabilities

- Add a URL with optional tags and title to the user's Pocket queue
- Retrieve saved items filtered by state, tag, content type, or modified-since timestamp
- Apply batch actions to archive, favourite, delete, or retag many items at once
- Run the OAuth request-token and access-token flow to authorise a new user
- List all tags the user has applied across their saved items
- Pull account stats covering item counts and reading activity

## Use cases

### Read-later pipeline from chat agents

Knowledge workers paste links into a chat agent and ask it to 'save this for later'. The agent calls Pocket's add endpoint with the URL and a context-derived tag, building a structured personal reading queue without manual triage. Retrieval later is one search-by-tag away.

Example prompt: Save https://example.com/long-read to Pocket with tags 'research' and 'ai-agents' and confirm the item id

### Tag-driven content recommender

Build a weekly digest by retrieving Pocket items with a specific tag added since the last digest run, summarising each, and emailing the result. The /get endpoint supports tag and since filters, so the digest job pulls only the new items rather than re-processing the full archive.

Example prompt: Retrieve all Pocket items with tag 'ml-papers' added since 2026-06-01 and produce a summarised digest

### Archive cleanup at scale

Power users accumulate thousands of saved items. The /send endpoint accepts a batch of actions in one request, so an agent can archive everything older than a threshold or retag a set of items without making a call per item. This is meaningfully cheaper than walking the queue one item at a time.

Example prompt: Archive all unread Pocket items older than 90 days in a single batch /send call

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/add` | Save a URL to the user's queue |
| POST | `/get` | Retrieve saved items with filters |
| POST | `/send` | Apply batch actions to many items |
| POST | `/oauth/request` | Request an OAuth request token |
| POST | `/oauth/authorize` | Exchange request token for access token |
| POST | `/tags/get` | List all tags applied across items |

## Key resources

- **Add** — Create a new saved item from a URL with optional tags and title
- **Get** — Retrieve saved items with state, tag, content-type, and time filters
- **Send** — Batch endpoint applying archive, favourite, delete, and tag actions
- **OAuth** — Request-token and access-token endpoints for authorising users
- **Tags** — List of all tags the user has applied
- **Stats** — Account-level metrics for item counts and reading activity

## Why Jentic

- **Setup:** Wiring Pocket by hand means passing both the consumer_key and a per-user access_token, running its OAuth request-and-authorize handshake, and shaping the add, get, and send payloads yourself. Through Jentic you install once, import the Pocket API from the API Directory, store the credentials once, and your agent calls it.
- **Permission scoping:** Pocket carries the action and item targets in the request body rather than a resource id in the path, so you limit the agent to the operations it needs, such as saving a URL or retrieving saved items. Because you pick the operation set, bulk changes through the send operation are not reachable unless you add it.
- **Credential handling:** Your Pocket consumer key and per-user access token are stored once, encrypted, by your own Jentic One instance and injected at execution time. They never enter the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'save a URL to read later' or 'list saved items', and Jentic returns the matching Pocket operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Pushbullet API** — Cross-device link and note pushing that pairs well with a Pocket-as-archive workflow
- **Typeform API** — Form responses can be auto-saved as tagged Pocket items for later review
- **Jotform API** — Submission-driven content capture that can feed Pocket via webhook

## FAQ

### Why is there no official OpenAPI spec for Pocket API?

Pocket does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Pocket API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Pocket API use?

Pocket uses a consumer_key plus a per-user access_token sent in the request body. The OAuth handshake at `/oauth/request` and `/oauth/authorize` mints the access_token. Through Jentic the consumer_key and access_token are vaulted and injected at execution time.

### Can I save a URL to Pocket through the API?

Yes. POST /add with the URL and optional tags or title creates a new saved item in the user's queue. The response returns the canonical item identifier you can later use with /send for batch operations.

### What are the rate limits for the Pocket API?

The OpenAPI spec does not encode explicit rate limits, but Pocket historically applies per-consumer-key and per-user-token thresholds. Use the /send batch endpoint for bulk modifications instead of looping /add or /modify, which keeps you well under the limits.

### How do I retrieve saved items filtered by tag through Jentic?

Search Jentic for 'get pocket items by tag', load the POST /get schema, then execute with the tag and optional since timestamp. Jentic injects the consumer_key and access_token automatically.

### Can I run multiple actions in one call?

Yes. POST /send accepts an actions array where each element is an archive, favourite, delete, tag-add, or tag-remove action. This is the supported way to perform bulk maintenance without flooding the per-item endpoints.

### Is the Pocket API free?

Pocket's API has historically been free for developers with a registered consumer_key, though Pocket's product status has shifted recently - check getpocket.com for current availability and any successor service before building production integrations.

### Can I limit what my agent is allowed to do with the Pocket API?

Yes. Because you run Jentic One yourself, your own rules decide which Pocket operations the agent can reach and which credentials it may use. Pocket carries the action and item targets in the request body rather than a resource id in the path, so you grant only the operations the agent needs, such as saving a URL with /add or retrieving saved items with /get. Bulk changes through the /send batch operation stay out of reach unless you explicitly add it to the agent's allowed set.