keep.md — The Safe Bookmark API for AI Agents

You bookmark 30 articles a week. Your AI agent can't read any of them. keep.md fixes that: it saves web content as clean markdown, gives your agent a REST API to search and read it, and auto-syncs your X bookmarks — through official channels, not scraping that gets your account banned.

Why This Matters: The X Automation Problem

If you run AI agents that interact with X (Twitter), you've hit the wall. X's API restrictions are aggressive and getting worse:

• Basic tier ($100/month): Can post original tweets. Cannot reply to others' tweets (returns 403). Cannot read DMs. Cannot access bookmark data.
• Pro tier ($5,000/month): Full API access including replies and bookmarks. Priced for enterprises, not solo founders.
• Scraping: X actively detects and bans accounts using browser automation to read bookmarks, timelines, or thread data. One ban and your audience is gone.

This creates a specific problem for agents that need to research, curate, and learn from content saved on X. You bookmark interesting threads, competitor insights, market signals — but your agent can't access any of it without risking your account or paying $5K/month.

keep.md solves this by syncing your X bookmarks through an official integration, converting them to markdown, and exposing them via a clean REST API your agent can query safely. No scraping. No API tier workarounds. No account risk.

How keep.md Works

The API: What Your Agent Can Do

All endpoints use Bearer token auth. Get your key from the keep.md dashboard. Base URL: https://keep.md/api

Save a URL

curl -X POST https://keep.md/api/ingest \
  -H "Authorization: Bearer $KEEP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/article"}'

# Response:
# {"ok": true, "id": "a1b2c3", "extracted": true}

The page is fetched in the background, extracted as markdown, and stored. Duplicate URLs are deduplicated automatically.

Search bookmarks

# Hybrid retrieval — searches titles, URLs, notes, tags, and content
curl "https://keep.md/api/items?q=AI+agent+memory&limit=5&content=1" \
  -H "Authorization: Bearer $KEEP_API_KEY"

The q parameter does hybrid retrieval — not just keyword matching. Returns items ranked by relevance with optional full markdown content.

Get the agent feed

# Returns unprocessed items — designed for agent consumption
curl "https://keep.md/api/feed?limit=10" \
  -H "Authorization: Bearer $KEEP_API_KEY"

# After processing, mark items so they don't reappear:
curl -X POST https://keep.md/api/items/mark-processed \
  -H "Authorization: Bearer $KEEP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"ids": ["a1b2c3", "d4e5f6"]}'

The /feed endpoint is purpose-built for agents: it returns only unprocessed items with full markdown. Your agent reads them, extracts what it needs, then marks them processed. Next time the agent checks, it only sees new content. This prevents reprocessing and keeps the agent's context fresh.

Read full content

# Get raw markdown for a single bookmark
curl https://keep.md/api/items/a1b2c3/content \
  -H "Authorization: Bearer $KEEP_API_KEY"

# Returns plain text markdown — the full extracted page

Integration Guide: OpenClaw

The fastest path is the agent skill — one command installs it:

npx playbooks add skill keep.md/docs

Once installed, your OpenClaw agent can search and read your bookmarks during any conversation. The skill registers keep's CLI commands as tools the agent can call.

Manual integration via cron job

For more control, set up a cron job that pulls your bookmark feed and writes it to the agent's context files:

#!/bin/bash
# keep-sync.sh — runs every 4 hours via cron
# Pulls unprocessed bookmarks and appends to today's context

KEEP_API_KEY="your-key-here"
TODAY=$(date +%Y-%m-%d)
CONTEXT_FILE="$HOME/.openclaw/workspace/memory/bookmarks-$TODAY.md"

# Fetch unprocessed items
FEED=$(curl -s "https://keep.md/api/feed?limit=20&content=1" \
  -H "Authorization: Bearer $KEEP_API_KEY")

COUNT=$(echo "$FEED" | jq '.count')
[ "$COUNT" -eq 0 ] && exit 0

# Append to today's context file
echo "$FEED" | jq -r '.items[] |
  "## " + .title + "\n" +
  "URL: " + .url + "\n" +
  "Saved: " + (.createdAt | todate) + "\n\n" +
  .contentMarkdown + "\n\n---\n"' >> "$CONTEXT_FILE"

# Mark as processed
IDS=$(echo "$FEED" | jq -c '[.items[].id]')
curl -s -X POST https://keep.md/api/items/mark-processed \
  -H "Authorization: Bearer $KEEP_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"ids\": $IDS}" > /dev/null

echo "Synced $COUNT bookmarks to $CONTEXT_FILE"

Cron entry:

0 */4 * * * /bin/bash ~/scripts/keep-sync.sh >> ~/logs/keep-sync.log 2>&1

Now your agent reads today's bookmarks as part of its daily context. When you bookmark an interesting X thread at 10 PM, your agent has it as context by the 2 AM sync.

Integration: n8n Workflow

For n8n users, the integration is a 3-node workflow:

1. Schedule Trigger — every 4 hours
2. HTTP Request node — GET https://keep.md/api/feed?limit=20&content=1 with Bearer auth header
3. Split + Process — for each item, write to a file, send to Slack, append to a Notion database, or feed to an AI node for summarization

A common pattern: n8n pulls the feed → sends each bookmark's markdown to Claude for a 2-sentence summary → posts the summaries to a Slack channel → marks the items processed. You get a curated, summarized research feed without ever opening a browser tab.

Use Cases

1. Research agent knowledge base

Bookmark competitor articles, industry reports, and thought-leader threads. Your research agent queries keep.md's API as its primary source when answering "what are competitors doing?" or "what's trending in [space]?" — drawing from content you've already vetted, not random web search results.

2. X intelligence pipeline

Bookmark interesting X threads as you scroll. keep.md syncs them automatically, extracts the full text (including quoted tweets and linked articles), and stores it as markdown. Your agent processes the feed nightly, extracting trends, tagging topics, and flagging content worth responding to. You get X intelligence without building a scraper or paying $5K/month for Pro API access.

3. Content inspiration feed

Bookmark articles you want to reference when writing. When your content agent is drafting a blog post or newsletter, it searches keep.md for relevant saved articles, pulls the markdown, and cites real sources instead of generating vague references. Your content is grounded in material you've actually read and approved.

4. YouTube research library

Save YouTube videos and keep.md extracts the transcript as markdown. Your agent can search across hours of video content by keyword — finding the exact segment where someone discussed a specific technique. No more rewatching entire videos to find the one minute that matters.

5. Background monitoring

Set up RSS feeds and YouTube channels as background sources. keep.md automatically saves new content when it's published. Your agent processes the feed daily, flagging anything relevant to your current projects. Passive monitoring without manual bookmarking.

Pricing

Based on the API documentation (March 2026):

• Free tier: 50 saved links (lifetime cap). Read requests are never rate-limited. Good for evaluating the tool and light personal use.
• Plus plan: Higher monthly link limits (exact count visible in your dashboard via /api/me). Monthly reset, not lifetime.
• Pro plan: Highest limits for power users and agent-heavy workflows. Monthly reset.

The /api/me endpoint returns your current plan, link limit, and usage count — your agent can check its own budget before saving new items.

When to Use keep.md vs. Alternatives

• Use keep.md when: You need your AI agent to access content you've bookmarked. The agent skill and feed/mark-processed API are purpose-built for this workflow. Nothing else combines X bookmark sync + markdown extraction + agent-ready API this cleanly.
• Use Pocket/Instapaper when: You just want to read articles later, personally. They don't have agent-facing APIs or markdown extraction.
• Use Notion when: You need a full knowledge management system with databases, relations, and team collaboration. Heavier, but more powerful for structured data.
• Use raw web_fetch when: You need one-off page reads and don't care about storing or searching across them later.

Getting Started

1. Now (2 min): Sign up at keep.md. Install the Chrome extension.
2. Now (3 min): Connect your X account to sync bookmarks.
3. Now (5 min): Get your API key from the dashboard. Run the /api/me curl to verify.
4. Today (5 min): Install the agent skill (npx playbooks add skill keep.md/docs) or set up the cron sync script.
5. This week: Bookmark 20-30 items normally. Check that your agent can search and retrieve them. Tune the sync frequency based on your bookmarking pace.