[Cotlet](https://cotlet.dev/index.md) · [Integrations](https://cotlet.dev/integrations.md) · [How it works](https://cotlet.dev/how-it-works.md) · [Use cases](https://cotlet.dev/use-cases.md) · [Security](https://cotlet.dev/security.md) · [For developers](https://cotlet.dev/for-developers.md) · [For automation agencies](https://cotlet.dev/for-agencies.md) · [Blog](https://cotlet.dev/blog.md) · [API docs](https://cotlet.dev/docs.md) · [Help center](https://cotlet.dev/help.md) · [Changelog](https://cotlet.dev/changelog.md) · [Contact](https://cotlet.dev/contact.md) · [Pricing](https://cotlet.dev/pricing.md) · [Sign up](https://cotlet.dev/signup)

# Feedly API and MCP server

> Feedly has a REST API, but only Enterprise clients can create a token, and its documented endpoints are built around Threat Intelligence (checked 17 Oct 2026). Feedly's official MCP server, Feedly Threat Graph, queries threat intelligence and needs an Advanced or Enterprise account. Neither one lets an agent work your own feeds, Read Later and read state.

News reader that follows websites, blogs and newsletters as sources, groups them into Feeds, and lets you save articles to Boards or Read Later.

## What is the Feedly API?

Cotlet's Feedly API exposes 14 endpoints for your own Feedly account: list feeds, list articles, get article, search articles, list Boards, search sources, save article to Board, add URL to Board, mark articles read or unread, mark a stream as read, save for later, follow source, unfollow source and move source to another Feed. The list_feeds endpoint returns your Feeds with the sources in each and the unread count. Each endpoint takes simple JSON inputs like stream, limit or article_id and works both as an operation of the feedly_read or feedly_write MCP tool for agents and as a REST call for scripts.

- **Category:** [Productivity & teams](https://cotlet.dev/integrations/category/productivity-teams.md)
- **Endpoints:** 14 (6 read, 8 write)
- **Updated:** 2026-10-21

Feedly has a REST API, but only Enterprise clients can create a token, and its documented endpoints are built around Threat Intelligence (checked 17 Oct 2026). Cotlet is a hosted MCP server and REST API for Feedly with 14 endpoints (6 read, 8 write): you sign in once in your own cloud browser, your AI agent does the work.

## Does Feedly have an official API?

Feedly has a REST API, but only Enterprise clients can create a token, and its documented endpoints are built around Threat Intelligence (checked 17 Oct 2026). Feedly's official MCP server, Feedly Threat Graph, queries threat intelligence and needs an Advanced or Enterprise account. Neither one lets an agent work your own feeds, Read Later and read state.

| Task | Feedly official | Cotlet |
|---|---|---|
| List feeds and their sources | Partly: API lists Team Folders and AI Feeds, Enterprise only | Yes |
| Read articles from a feed, source or Board | Partly: Collect articles endpoint, Enterprise API add-on | Yes |
| Search articles | Partly: Search endpoint, Enterprise API add-on | Yes |
| Save an article to a Board | Partly: API adds articles to Team Boards; Zapier has an Add Article to Board action | Yes |
| Mark articles as read | Partly: Feedly says any in-app action can be done through the API, but the endpoint reference lists none for read state | Yes |
| Follow a source into a Feed | Partly: Zapier has a Subscribe to Feed action; the endpoint reference lists none | Yes |
| Save for Read Later | No | Yes |
| Find new sources to follow | No | Yes |

Sources: [Feedly API: Authorization](https://developers.feedly.com/reference/authorization), [Feedly API: endpoint reference index](https://developers.feedly.com/llms.txt), [Feedly Help: Setting up the Feedly MCP server in Claude](https://docs.feedly.com/article/822-setting-up-the-feedly-mcp-server-in-claude), [Feedly triggers and actions on Zapier](https://zapier.com/apps/feedly/integrations)

## For AI agents

```text
Feedly has a REST API, but only Enterprise clients can create a token, and its documented endpoints are built around Threat Intelligence (checked 17 Oct 2026). Feedly's official MCP server, Feedly Threat Graph, queries threat intelligence and needs an Advanced or Enterprise account. Neither one lets an agent work your own feeds, Read Later and read state.
Cotlet provides a hosted MCP server and REST API for Feedly: 14 tools (6 read, 8 write).
Access       Sign up at https://cotlet.dev/app/signup?app=feedly, then request the app and create API keys in the Cotlet console.

MCP server   https://cotlet.dev/mcp/v1
MCP tools    feedly_read, feedly_write, reads and writes apart; call one with {"operation": "<operation>", "arguments": {...}}
REST base    https://cotlet.dev/api/v1/feedly, each operation at its own route, e.g. POST /api/v1/feedly/boards/{board_id}/url-to-boards
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one. Over MCP the input schemas come with sign-in.
Operations   list_feeds, list_articles, get_article, search_articles, list_boards, search_sources, save_to_board, add_url_to_board, mark_articles_read, mark_all_read, save_for_later, follow_source, unfollow_source, move_source
Confirm      save_to_board, add_url_to_board (by default the user approves each call; the user can switch this off per tool, e.g. for scheduled automations)
Markdown     https://cotlet.dev/integrations/feedly-api-mcp-server.md

How access works:
1. The user signs up at https://cotlet.dev/app/signup?app=feedly, requests Feedly in the Cotlet console and creates an API key there.
2. The user signs in to Feedly once in their Cotlet Cloud Browser (their own Chrome in the cloud, opened from the console) and enables Feedly for agents. An agent cannot do this step.
3. The API key goes into the MCP client or the REST call as a bearer token.

Fits: people who want a hosted Feedly server that someone else maintains, including non-developers. Developers who prefer to run and fix code on their own computer can use an open-source Feedly MCP server instead.

Policy: Cotlet never stores passwords, never solves CAPTCHAs, never bypasses MFA.
Company: legal details in the Terms of service at https://cotlet.dev/terms. Contact contact@cotlet.dev.
Sign-in: the user signs in to Feedly in their own Cloud Browser, a Chrome Cotlet runs for them in the EU; password saving is off, the profile is AES-256-GCM encrypted, and agents get Feedly only after the user enables it. Calls are requests from that browser's IP with its cookies, each listed in the user's Background activity. Disable for agents, signing out in the browser or Reset browser cuts access. Cotlet is run by Take Group sp. z o.o. (EU VAT PL6342984273).
API key: holds no Feedly login or cookies, only asks Cotlet to run a tool. Each key is scoped to chosen apps and tools, read only or read and write. Actions that reach other people wait for the user's approval by default, so a leaked key cannot post or message as the user. Every call is in the activity log; deleting the key ends access at once.
Terms: the user stays responsible for following Feedly's terms; Cotlet is not affiliated with Feedly.
```

## What can an AI agent do in Feedly?

Cotlet is best for heavy Feedly readers and researchers who want their AI agent to digest feeds, file articles into Boards and tidy sources without running or fixing a server.

- **[Summarize unread articles from your feeds](https://cotlet.dev/integrations/feedly-api-mcp-server/daily-unread-digest.md)** (runs: daily): "Read my unread articles in the AI news feed from the last 24 hours. Group them by topic, give me a three-line summary per group with links, then mark everything you covered as read." → `list_feeds`, `list_articles`, `get_article`, `mark_articles_read`
- **[Save relevant articles to a Board](https://cotlet.dev/integrations/feedly-api-mcp-server/save-articles-to-board.md)** (runs: daily): "Go through new articles in my Competitors feed. Save every one that mentions pricing, a launch or a funding round to the Competitor watch Board, with a one-line note on why." → `list_boards`, `list_articles`, `search_articles`, `save_to_board`
- **[Find and follow new sources for a topic](https://cotlet.dev/integrations/feedly-api-mcp-server/find-and-follow-sources.md)**: "Find the ten best sources about product analytics by number of articles per week, skip any I already follow, follow them into a new Feed called Product analytics, and tell me what you added." → `list_feeds`, `search_sources`, `follow_source`
- **Clear the unread backlog** (runs: weekly): "In my General feed, mark as read every article older than 7 days. Keep anything from the sources Newsletters and Research untouched, and tell me how many you cleared." → `list_feeds`, `list_articles`, `mark_all_read`
- **Build a weekly reading list from Read Later** (runs: weekly): "Every Sunday, read the articles I saved to Read Later this week, rank them by how relevant they are to my product work, and give me a reading list of five with one line on why each is worth my time." → `list_articles`, `get_article`, `save_for_later`

## Can Feedly automations run on a schedule in n8n, Make or Zapier?

Yes. Cotlet does not replace your automation platform: it gives it a Feedly connection it does not have, with the same API key as your agent. Write actions ask for your OK by default; switch that off in your dashboard for the tools you choose, for example to summarize unread articles from your feeds, and the schedule runs on its own. Cotlet runs in the cloud, so it keeps going while your computer is off.

| Where | How to connect | How to schedule |
|---|---|---|
| Your AI agent | Add https://cotlet.dev/mcp/v1 with your API key. | A scheduled agent run, for example a Claude Code routine. |
| n8n | MCP Client node with https://cotlet.dev/mcp/v1, or an HTTP Request node with the endpoint's method and URL, such as GET https://cotlet.dev/api/v1/feedly/feeds. | Schedule Trigger node. |
| Make | HTTP module: the endpoint's method and URL with an Authorization: Bearer header, and a JSON body for POST, PUT and PATCH. | Scenario schedule. |
| Zapier | Webhooks by Zapier, Custom Request: the same method, URL, header and body. | Schedule by Zapier trigger. |
| Your own script | GET https://cotlet.dev/api/v1/feedly/feeds with your API key. | cron or GitHub Actions. |

## Tools

**For AI agents:** Every endpoint and its schema is public. The 14 endpoints on this page, with parameters and example responses, can be listed without an account. Calling one returns 401 without an API key and 403 while the key has no access to Feedly.

### list_feeds

Your Feeds with the sources in each and the unread count. Access: read. REST: `GET /api/v1/feedly/feeds`. MCP: `feedly_read → list_feeds`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `include_sources` | boolean | no | false returns Feeds only. Default: true. |

Returns every Feed in your account, personal and team, with its sources and the unread count for each. Team Feeds appear only if your account has them. Use feed_id and source_id from this call in list_articles, follow_source and move_source.

Example response:

```json
{
  "feeds": [
    {
      "feed_id": "feed_ai01",
      "name": "AI news",
      "type": "personal",
      "unread_count": 23,
      "sources": [
        {
          "source_id": "src_a11f02",
          "title": "Model Releases Weekly",
          "website": "example-models.com",
          "unread_count": 14
        },
        {
          "source_id": "src_a11f09",
          "title": "Agent Tooling Digest",
          "website": "example-agents.dev",
          "unread_count": 9
        }
      ]
    },
    {
      "feed_id": "feed_ds02",
      "name": "Design",
      "type": "personal",
      "unread_count": 10,
      "sources": [
        {
          "source_id": "src_d3c410",
          "title": "Interface Notes",
          "website": "example-interface.io",
          "unread_count": 6
        },
        {
          "source_id": "src_d3c41b",
          "title": "Type and Layout",
          "website": "example-type.co",
          "unread_count": 4
        }
      ]
    }
  ]
}
```

### list_articles

Articles in a Feed, source, Board or Read Later, newest first, with read state. Access: read. REST: `GET /api/v1/feedly/articles`. MCP: `feedly_read → list_articles`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `stream` | string | yes | A feed_id or source_id from list_feeds, a board_id from list_boards, or 'read_later'. |
| `unread_only` | boolean | no | false includes read articles. Default: true. |
| `since` | datetime | no | Only articles published after this time. |
| `limit` | integer | no | 1 to 50. Default: 20. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists articles from one stream, newest first: a Feed, a single source, a Board, or Read Later. The body is a short preview; get_article returns the full text. By default only unread articles come back. Reading a list does not mark anything as read.

Example response:

```json
{
  "articles": [
    {
      "article_id": "art_9d41e0",
      "title": "Two open-weight models ship in one week",
      "source": "Model Releases Weekly",
      "url": "https://example-models.com/two-open-weight-models",
      "published_at": "2026-10-16T18:20:00Z",
      "unread": true,
      "read_later": false,
      "boards": [],
      "preview": "Both models run on a single GPU and ship with permissive licences..."
    }
  ],
  "next_cursor": "eyJvZmZzZXQiOjIwfQ"
}
```

### get_article

Full article text with source, link, read state and the Boards it is saved in. Access: read. REST: `GET /api/v1/feedly/articles/{article_id}`. MCP: `feedly_read → get_article`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `article_id` | string | yes | Article ID from list_articles or search_articles. |

Returns one article with the full text Feedly shows in its reader, the link to the original, whether it is unread or in Read Later, and the Boards that already hold it. Use it before summarizing or filing an article, so the agent works from the full text and not the preview.

Example response:

```json
{
  "article_id": "art_9d41e0",
  "title": "Two open-weight models ship in one week",
  "source": "Model Releases Weekly",
  "author": "Jo Marsh",
  "url": "https://example-models.com/two-open-weight-models",
  "published_at": "2026-10-16T18:20:00Z",
  "unread": true,
  "read_later": false,
  "boards": [],
  "content": "Two open-weight models shipped within days of each other. Both run on a single GPU..."
}
```

### search_articles

Search article text in your Feeds, optionally inside one stream. Access: read. REST: `GET /api/v1/feedly/articles/search`. MCP: `feedly_read → search_articles`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `query` | string | yes | Search words. |
| `stream` | string | no | Limit to a feed_id, source_id or board_id. |
| `limit` | integer | no | 1 to 50. Default: 20. |
| `cursor` | string | no | Next page cursor from the previous call. |

Runs a search over the articles in your Feeds and returns matches with the same fields as list_articles, best match first. Pass stream to search one Feed, source or Board only. Search follows what your Feedly plan includes; if your plan has no search, the call returns an error that says so.

Example response:

```json
{
  "articles": [
    {
      "article_id": "art_b7720c",
      "title": "Northwind launches team workspaces",
      "source": "SaaS Launch Log",
      "url": "https://example-launches.com/northwind-team-workspaces",
      "published_at": "2026-10-15T09:05:00Z",
      "unread": true,
      "read_later": false,
      "boards": [
        "Competitor watch"
      ],
      "preview": "Northwind added shared workspaces for teams of any size..."
    }
  ],
  "next_cursor": null
}
```

### list_boards

Your Boards, personal and team, with the number of articles in each. Access: read. REST: `GET /api/v1/feedly/boards`. MCP: `feedly_read → list_boards`.

No parameters.

Lists your Boards with their type, personal or team, and the number of articles saved. Team Boards are shared with your team, so check the type before a save. Use board_id in save_to_board, add_url_to_board and list_articles.

Example response:

```json
{
  "boards": [
    {
      "board_id": "board_77a1",
      "name": "Competitor watch",
      "type": "team",
      "article_count": 42
    },
    {
      "board_id": "board_31c0",
      "name": "Reading list",
      "type": "personal",
      "article_count": 17
    }
  ]
}
```

### search_sources

Search Follow Sources for websites and feeds by topic, with followers and posting rate. Access: read. REST: `GET /api/v1/feedly/sources/search`. MCP: `feedly_read → search_sources`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `query` | string | yes | Topic, website or feed URL. |
| `sort` | string | no | 'relevance', 'followers' or 'articles_per_week'. Default: relevance. |
| `limit` | integer | no | 1 to 30. Default: 10. |

Searches Feedly for sources on a topic, the same search as Follow Sources. Sort by relevance, followers or articles per week. Each result says whether you already follow it. Pass source_id to follow_source.

Example response:

```json
{
  "sources": [
    {
      "source_id": "src_5b21c7",
      "title": "Example Analytics Weekly",
      "website": "example-analytics.com",
      "followers": 18400,
      "articles_per_week": 14,
      "followed": false
    },
    {
      "source_id": "src_5b21d3",
      "title": "Growth Letters",
      "website": "example-growth.com",
      "followers": 9200,
      "articles_per_week": 6,
      "followed": true
    }
  ]
}
```

### save_to_board

Save an article to a Board, the star icon in the reader. Access: write, asks the user first. REST: `POST /api/v1/feedly/articles/{article_id}/boards/{board_id}/save`. MCP: `feedly_write → save_to_board`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `article_id` | string | yes | Article ID from list_articles or search_articles. |
| `board_id` | string | yes | Board ID from list_boards. |

Saves one article to a Board, the same as the star icon at the top of an article. An article can sit in more than one Board; saving it twice to one Board changes nothing. A Team Board shows the article to your team. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "article_id": "art_9d41e0",
  "board_id": "board_77a1",
  "board_name": "Competitor watch",
  "saved": true
}
```

### add_url_to_board

Add a web page or PDF that is not in your Feeds to a Board, with a note. Access: write, asks the user first. REST: `POST /api/v1/feedly/boards/{board_id}/url-to-boards`. MCP: `feedly_write → add_url_to_board`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `board_id` | string | yes | Board ID from list_boards. |
| `url` | string | yes | Page or PDF URL. |
| `note` | string | no | Note saved with the page. |

Adds a page by its URL to a Board, like the + option on a Board. Feedly loads the page first, then saves it with your note. Works for PDFs. A Team Board shows the page to your team. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "board_id": "board_31c0",
  "board_name": "Reading list",
  "url": "https://example-research.org/state-of-feeds.pdf",
  "title": "State of feeds report",
  "note": "Chapter 3 compares polling and push.",
  "saved": true
}
```

### mark_articles_read

Mark articles as read or unread, optionally hiding them from the list. Access: write. REST: `POST /api/v1/feedly/articles-read/mark`. MCP: `feedly_write → mark_articles_read`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `article_ids` | string[] | yes | Article IDs from list_articles or search_articles. |
| `state` | string | no | 'read' or 'unread'. Default: read. |
| `hide` | boolean | no | true also hides read articles from the list. Default: false. |

Sets the read state of the articles you name. hide: true is Feedly's Mark as read and hide, which removes the article from the list until a reload; the default only lowers the unread count. It changes your read state only and reaches no one, even in a Team Feed. mark_articles_read runs without asking first, and state 'unread' undoes it in one call.

Example response:

```json
{
  "updated": 3,
  "state": "read",
  "hide": false,
  "article_ids": [
    "art_9d41e0",
    "art_9d41e1",
    "art_9d41e2"
  ]
}
```

### mark_all_read

Mark every article in a Feed or source as read, optionally only older ones. Access: write. REST: `POST /api/v1/feedly/all-read/mark`. MCP: `feedly_write → mark_all_read`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `stream` | string | yes | A feed_id or source_id from list_feeds. |
| `older_than` | datetime | no | Only articles published before this time. |

Marks all unread articles in one Feed or source as read, the same as Shift + A on a list. older_than limits it to articles published before that time. The call returns the article IDs it changed, so mark_articles_read with state 'unread' restores them in one call. It changes your read state only and runs without asking first.

Example response:

```json
{
  "stream": "feed_gen03",
  "marked": 3,
  "article_ids": [
    "art_c4410a",
    "art_c4410b",
    "art_c4410c"
  ]
}
```

### save_for_later

Add an article to Read Later, or remove it. Access: write. REST: `POST /api/v1/feedly/articles/{article_id}/later/save`. MCP: `feedly_write → save_for_later`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `article_id` | string | yes | Article ID from list_articles or search_articles. |
| `saved` | boolean | no | false removes it from Read Later. Default: true. |

Adds one article to Read Later, the same as the S shortcut. Set saved to false to remove it. Read Later is yours alone, so the call reaches no one and runs without asking first; saved: false undoes it.

Example response:

```json
{
  "article_id": "art_9d41e1",
  "saved": true
}
```

### follow_source

Follow a source and add it to a Feed, creating the Feed if you name a new one. Access: write. REST: `POST /api/v1/feedly/source/follow`. MCP: `feedly_write → follow_source`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `source` | string | yes | source_id from search_sources, or a website or feed URL. |
| `feed_id` | string | no | Existing Feed to add it to. Use this or new_feed_name. |
| `new_feed_name` | string | no | Create a Feed with this name and add the source to it. |

Follows a source, as Follow does in Follow Sources, and adds it to a Feed. Pass feed_id for an existing Feed, or new_feed_name to create one in the same step. Following changes your account only and reaches no one, so follow_source runs without asking first; unfollow_source undoes it.

Example response:

```json
{
  "source_id": "src_5b21c7",
  "title": "Example Analytics Weekly",
  "feed_id": "feed_pa01",
  "feed_name": "Product analytics",
  "followed": true
}
```

### unfollow_source

Stop following a source. Access: write. REST: `POST /api/v1/feedly/sources/{source_id}/unfollow`. MCP: `feedly_write → unfollow_source`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `source_id` | string | yes | Source ID from list_feeds. |

Unfollows a source, as the Unfollow option does in the sidebar or on the Organize page. Articles you saved to Boards or Read Later from it stay there. It changes your account only and runs without asking first; follow_source undoes it.

Example response:

```json
{
  "source_id": "src_5b21d3",
  "title": "Growth Letters",
  "followed": false
}
```

### move_source

Move a source you follow from one Feed to another. Access: write. REST: `POST /api/v1/feedly/to-feeds/{to_feed_id}/sources/{source_id}/move`. MCP: `feedly_write → move_source`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `source_id` | string | yes | Source ID from list_feeds. |
| `to_feed_id` | string | yes | Feed to move it to, from list_feeds. |

Moves a source between two of your Feeds, like rearranging on the Organize page. The source keeps its articles and read state. It changes your layout only and runs without asking first; moving it back undoes it.

Example response:

```json
{
  "source_id": "src_d3c410",
  "from_feed": "General",
  "to_feed": "Design",
  "moved": true
}
```

## How do I connect Feedly to Claude Code, Codex or Cursor?

Connecting Feedly takes three steps: sign up, sign in to Feedly once in your Cloud Browser and enable it for agents, then add one MCP server or call the REST API with the same key.

### Connect Feedly to your agent.

1. **Create an account** Sign up and add Feedly in the console. Your API key is there too.

2. **Sign in to Feedly in your Cloud Browser** Open your Cloud Browser in the console: your own Chrome in the cloud. Sign in to Feedly there yourself, the way you always do, then press Enable for agents, read only or read and write. We never save your password, and your agent keeps working even when your computer is off.

3. **Add Cotlet to your agent** Paste the snippet for your client. The same server and key serve every app you connect, so you do this once.

   Claude Code:

```
claude mcp add --transport http cotlet \
  https://cotlet.dev/mcp/v1 \
  --header "Authorization: Bearer $COTLET_API_KEY"
```

   Cursor:

```
{
  "mcpServers": {
    "cotlet": {
      "url": "https://cotlet.dev/mcp/v1",
      "headers": {
        "Authorization": "Bearer ${COTLET_API_KEY}"
      }
    }
  }
}
```

   Codex:

```
# ~/.codex/config.toml
[mcp_servers.cotlet]
url = "https://cotlet.dev/mcp/v1"
bearer_token_env_var = "COTLET_API_KEY"
```

4. **Ask your agent** Ask in plain words. Your agent finds the Feedly tools on the server and calls them for you; anything that reaches other people waits for your OK unless you switch that off for a tool.

```
Read my unread articles in the AI news feed from the last 24 hours. Group them by topic, give me a three-line summary per group with links, then mark everything you covered as read.
```

### Call Feedly from your scripts.

1. **Export your API key** Your scripts use the same API key as your agent. Keep it in an environment variable, never in your code.

```
export COTLET_API_KEY="cotlet_..."
```

2. **Call a tool** Every tool is an endpoint under /api/v1/feedly with its own method and path, listed with the endpoints above. Path parameters go in the URL; the other parameters go in the query for GET and DELETE and in a JSON body otherwise.

```
curl -X POST https://cotlet.dev/api/v1/feedly/boards/board_31c0/url-to-boards \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example-research.org/state-of-feeds.pdf","note":"Chapter 3 compares polling and push."}'
```

3. **Read the result** You get plain JSON back, ready for your script. A failed call costs nothing.

```
{
  "board_id": "board_31c0",
  "board_name": "Reading list",
  "url": "https://example-research.org/state-of-feeds.pdf",
  "title": "State of feeds report",
  "note": "Chapter 3 compares polling and push.",
  "saved": true
}
```

## Why use Cotlet for Feedly?

**Built for agents**

- One MCP server for every app you connect.
- The same tools as a REST API for scripts and cron jobs.
- Works with Claude Code, Codex and Cursor.

**Your login stays yours**

- You sign in to Feedly yourself, in your own Cloud Browser. We never save your password; the profile is encrypted with AES-256-GCM, the cipher 1Password uses.
- A+ on Qualys SSL Labs, securityheaders.com and Mozilla Observatory.
- The model never sees a login.
- No stored passwords, no CAPTCHA solving, no MFA bypass.

**You stay in control**

- Scope each API key: its apps, its tools, read only or read and write.
- Anything that reaches other people waits for your OK, so a leaked key cannot post or message as you.
- Every background request listed in your Background activity. Disable for agents in one click.

**Kept working for you**

- We test every integration every 6 hours.
- When Feedly changes, the tool pauses until we fix it.
- Failed calls cost nothing.

## Is it safe to connect Feedly to Cotlet?

Yes. You sign in to Feedly yourself, in your own Cloud Browser, and we never save your password. Your agents only get Feedly once you enable it, and every background request is listed. The browser profile is stored encrypted with AES-256-GCM, the same cipher 1Password uses for its vaults and Apple for iCloud Keychain. Independent public scanners grade cotlet.dev A+ and find it clean; click a result to rerun it yourself.

- **A+ on Qualys SSL Labs**: Encryption in transit: TLS setup and certificates, on all four server addresses. [Live result](https://www.ssllabs.com/ssltest/analyze.html?d=cotlet.dev)
- **A+ on securityheaders.com**: Browser protections sent with every page, all six headers present. [Live result](https://securityheaders.com/?q=cotlet.dev&followRedirects=on)
- **A+ on Mozilla Observatory**: Mozilla's web security baseline: score 120 of 100, 12 of 12 tests passed. [Live result](https://developer.mozilla.org/en-US/observatory/analyze?host=cotlet.dev)
- **Clean on Sucuri SiteCheck**: No malware, spam or defacement, and not on any of 9 blocklists, Google Safe Browsing included. [Live result](https://sitecheck.sucuri.net/results/cotlet.dev)

[How Cotlet protects your access](https://cotlet.dev/security.md)

### Common concerns

**Who runs Cotlet?**

Cotlet is run by Take Group, a Polish software company working since 2019. Take Group runs about 3,200 websites on its own systems and has its own DevOps team for infrastructure security. We built and used integrations like this inside the company for years before opening them as Cotlet.

**Is this an official Feedly integration?**

No, Cotlet is independent of Feedly. Feedly's own API is too limited for this work. Cotlet works through your own Feedly account, the way you use Feedly in the browser, so you need no partner approval and no developer setup.

**What about client data and GDPR?**

Cotlet is run from the EU and follows the GDPR. Cloud Browsers run in Finland, a Tier 1 country in the ITU Global Cybersecurity Index 2024. Data passes through a call and is not kept after it.

**Can I start with read only?**

Yes. Enable the app for agents as read only, or make the API key read only, and anything that reaches other people waits for your OK unless you switch that off per tool.

**Is it reliable?**

Every Cotlet service is checked every 3 minutes from Europe, North America, Asia and Australia. The live results and any outage are public at status.cotlet.dev.

**How do I stop?**

Press Disable for agents next to Feedly in your console: your agents lose access at once and you stay signed in. Signing out of Feedly in the browser works too, and Reset browser deletes the whole profile.

## Is there a Feedly MCP server on GitHub?

Yes. Community Feedly MCP servers exist on GitHub, usually maintained by one person. You install one on your own computer, connect it to Feedly, and keep it running yourself; when Feedly changes, it stops working until you or the maintainer fix it. Cotlet hosts the same kind of server for you, and our team keeps it working.

|  | GitHub MCP server | Cotlet |
|---|---|---|
| Setup | Clone the repo, install it, connect it to Feedly, add it to each MCP client | Sign up, sign in to Feedly once, add one MCP server or API key |
| When Feedly changes | It breaks until you or the maintainer fix it | Our team tests it daily and fixes it for you; failed calls are free |
| Your Feedly session | In a file on your computer, readable by any program you run | In your own Cloud Browser in the EU, profile encrypted, only for the apps you enable, disabled for agents in one click |
| When the session expires | Tools fail until you sign in again by hand | Your Cloud Browser keeps you signed in; if Feedly logs you out, your agent gets a link to sign in again |
| Upkeep | You update, monitor and debug it yourself | Nothing to host or update |
| Where it runs | Your computer, while it is on | Hosted: Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | Free, paid for with your time | Free 7-day trial, then pay-as-you-go credit packs, no subscription |

### Which one fits you

**Pick Cotlet if**

- you are not a developer, or you do not want to maintain a server
- you need it to keep working when Feedly changes, without checking it yourself
- your agent or a script should run it on a schedule, also while your computer is off

**Pick an open-source server if**

- you are comfortable installing, updating and fixing it yourself
- you want your sign-in to stay on your own computer
- you only need it now and then, from one MCP client

## How much does the Feedly API cost?

Free 7-day trial with 2,000 credits, no card needed. After that, the Feedly API is pay as you go with no limit on apps: Credit packs from $29 for 5,000 credits, one-time, no subscription. A successful call uses 20 to 30 credits (25 for most tools, about $0.10 to $0.15), your Cloud Browser uses 50 credits a day while it has an app enabled for agents, however many apps that is, and an agent driving the browser itself uses 5 credits a minute. Credit packs stay valid for 12 months and stack, so unused credits carry over.

| Credits | Price, one time | Calls at 25 credits | Per 1,000 credits |
|---|---|---|---|
| 5,000 | $29 | 200 | $5.80 |
| 15,000 | $79 | 600 | $5.27 |
| 32,000 | $149 | 1,280 | $4.66 |
| 60,000 | $249 | 2,400 | $4.15 |

Only successful calls use credits; failed calls and timeouts cost nothing. At a balance of 0 calls pause, never a surprise charge. Authenticate with the `Authorization: Bearer` header. [See full pricing](https://cotlet.dev/pricing.md)

## How Cotlet holds your access

Cotlet hosts MCP servers and REST APIs for apps with no usable API. Your agent works in your own Feedly account.

- **Company details:** Cotlet is run by Take Group sp. z o.o., a company registered in Poland. Its full address and registration numbers are in the Terms of service. [Terms of service](https://cotlet.dev/terms)
- **Your sign-in:** You sign in to Feedly yourself, in your own Cloud Browser: a Chrome we run for you in the EU, one per app. We never save your password (password saving is off), the profile is stored encrypted with AES-256-GCM, and your agents get Feedly only after you enable it. When Feedly signs you out, your agent gives you a link to sign in again. [Security](https://cotlet.dev/security.md)
- **Revoking access:** Press Disable for agents next to Feedly, sign out of Feedly in your Cloud Browser, or reset the browser. Every background request is listed in your Background activity. Actions that reach other people wait for your OK unless you switch that off per tool.
- **What we never do:** Store passwords, solve CAPTCHAs or bypass MFA.
- **Feedly's terms:** You use your own Feedly account and stay responsible for following Feedly's terms. Cotlet is independent and not affiliated with Feedly. [Terms](https://cotlet.dev/terms)
- **Contact:** Questions about the company, security or an app: [contact@cotlet.dev](mailto:contact@cotlet.dev)

## Frequently asked questions

**How do I get access?**

Sign up free, open Feedly in the console and press Request access. Then you create your API key and connect Feedly there.

**Do I need to be technical?**

No. You sign in to Feedly once in your Cloud Browser, a normal Chrome you open from the console, and paste one command into your agent, or one URL into n8n. Your agent can walk you through it. There is no server to install, update or fix.

**Is it safe to connect Feedly to Cotlet?**

Yes. You sign in to Feedly yourself, in your own Cloud Browser in the EU, and we never save your password. Your agents only get Feedly once you enable it, every background request is listed, and the browser profile is stored encrypted with AES-256-GCM, the cipher 1Password uses for its vaults. The AI model never sees a login, posts and messages wait for your OK, and Disable for agents cuts access in one click. Independent scanners grade cotlet.dev A+ on Qualys SSL Labs, securityheaders.com and Mozilla Observatory; live results are on https://cotlet.dev/security.

**Is a hosted server safer than a local one? My Feedly sign-in would leave my computer.**

On Cotlet you sign in inside your own Cloud Browser, which only you open, and its profile is stored encrypted with AES-256-GCM in the EU. Agents get only the apps you enable, and every background request is listed. A local server keeps your Feedly cookie in a plain file on your computer, readable by any program you run, and stops when your computer is off.

**Why does Cotlet send requests instead of clicking in my browser?**

To be fast, Cotlet doesn't click through Feedly's pages. It sends the same requests your browser would, from your browser's IP with its cookies, without opening a window. Feedly sees the same browser and IP you signed in with, and every request is listed in your Background activity.

**What if someone gets my Cotlet API key?**

The key holds no Feedly login or cookies, it only asks Cotlet to run a tool. It can call only the apps and tools you gave it, and a read-only key changes nothing. Anything that reaches other people, like posts, comments or messages, waits for your OK in the dashboard by default, so a leaked key cannot post or message as you. When you switch approval off for a scheduled job, give that job its own key limited to that one tool. Every call is in your activity log, and deleting the key ends access at once.

**Why a signed-in browser and not OAuth, like other integration platforms?**

Feedly offers no OAuth token you can simply grant for these tools: its official API leaves them out or needs a developer app, a plan or an approval first (see the official API section above). That is why Cotlet sets the limits itself: per key, per tool, with your approval before anything reaches other people. Cotlet is run by Take Group sp. z o.o., an EU company (VAT PL6342984273).

**Do I need Feedly's API add-on or an Enterprise plan?**

No. Cotlet works in your own Feedly account and uses no API token. Feedly says self-service API tokens are only available to Enterprise clients, and that the API is an add-on you arrange with its sales team.

**What happens to unread counts when my agent marks articles as read?**

mark_articles_read lowers the unread count for the source and Feed, the same as Feedly's Mark as read. With hide set to true it also removes the articles from the list until you reload. In a Team Feed, read status is per person, so teammates still see their own unread articles.

**Can my agent post or send messages in Feedly without asking me?**

No. Every call to save_to_board or add_url_to_board waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals. mark_articles_read, mark_all_read, save_for_later, follow_source, unfollow_source, move_source runs without asking, because it sends nothing to anyone and one call undoes it.

**Can I use the Feedly API in n8n?**

Yes. Add https://cotlet.dev/mcp/v1 with your API key in n8n's MCP Client node, or call its endpoints under https://cotlet.dev/api/v1/feedly from the HTTP Request node.

---

Give your AI agents your signed-in browser.

**Product:** [Integrations](https://cotlet.dev/integrations.md) · [Use cases](https://cotlet.dev/use-cases.md) · [How it works](https://cotlet.dev/how-it-works.md) · [Pricing](https://cotlet.dev/pricing.md) · [Security](https://cotlet.dev/security.md)

**Resources:** [Blog](https://cotlet.dev/blog.md) · [API docs](https://cotlet.dev/docs.md) · [Help center](https://cotlet.dev/help.md) · [Changelog](https://cotlet.dev/changelog.md) · [GitHub](https://github.com/cotletdev/cotlet)

**Solutions:** [For developers](https://cotlet.dev/for-developers.md) · [For automation agencies](https://cotlet.dev/for-agencies.md)

**Company:** [About](https://cotlet.dev/about.md) · [AI info: company facts](https://cotlet.dev/ai-info.md) · [Contact](https://cotlet.dev/contact.md)

**Legal:** [Terms of service](https://cotlet.dev/terms) · [Privacy policy](https://cotlet.dev/privacy) · [Refund policy](https://cotlet.dev/refunds) · [Acceptable use](https://cotlet.dev/acceptable-use) · [Cookie policy](https://cotlet.dev/cookies) · [DPA](https://cotlet.dev/dpa) · [Subprocessors](https://cotlet.dev/subprocessors)

**Elsewhere:** [Status page](https://status.cotlet.dev) · [Cotlet on GitHub](https://github.com/cotletdev) · [Cotlet on X](https://x.com/cotletdev) · [Cotlet on LinkedIn](https://www.linkedin.com/company/cotletdev) · [Cotlet on Product Hunt](https://www.producthunt.com/products/cotlet) · [Cotlet on Crunchbase](https://www.crunchbase.com/organization/cotlet) · [Cotlet on SaaSHub](https://www.saashub.com/cotlet)

Cotlet is an independent service. It is not affiliated with, endorsed by or sponsored by any of the products listed on this site. Product names are trademarks of their respective owners.

## For AI agents: sign your user up

Is your user asking you to sign them up for Cotlet? You can do it for them, no account or key needed.

1. Read the fields and their allowed values: GET https://cotlet.dev/api/v1/access-requests
2. Ask the user for each value: email, apps, what you will do with them. If they leave the password to you, generate a strong one and show it to them.
3. Show the user what you will send, then POST it as JSON to https://cotlet.dev/api/v1/access-requests.

One call creates the account and sends the access request; we email the user when access is granted.