Opedd — Licensed Content for AI MCP Server

by opedd Your server? Claim it

answering

Opedd — Licensed Content for AI is answering right now. Last checked 1 min ago. 496 installs a week from npm. It exposes 18 tools. Last commit 17 Sep 2026.

Licensed, rights-cleared content for AI agents - verifiable license keys + EU AI Act attestation.

Installs per day peak 490 · avg 93 · +67% w/w

a month agotoday

Uptime history 47 days of history · worst day 59%

47 days agonow

75.0%

Uptime 24h

69 of 92 checks

Tools

read from the server

564 ms

Response time

average over 24h

496

Installs / week

npm and PyPI

What changed 12

Every tool that appeared, vanished or quietly changed what it asks for. Recorded since 26 August 2026. No other catalogue keeps this.

15 Sep a tool appeared search_content

15 Sep a tool description was rewritten list_publisher_content

15 Sep a tool changed the parameters it asks for list_publisher_content

15 Sep a tool changed version

31 Aug a tool description was rewritten push_content

31 Aug a tool changed version

26 Aug 4 tool descriptions were rewritten article_53_attestation, get_audit_events, get_buyer_account and 1 more

26 Aug a tool changed version2 times that day

and 1 more, back to 26 August 2026

Opedd — Licensed Content for AI does not always answer

Over the last week it answered 81.6% of our checks. We check every 15 minutes, so you hear about the next outage within the hour — not from your users.

Connect this server

Endpoint below is the one we actually reach during checks — not the one copied from a README. Last verified 1 min ago.

Claude Code Claude Desktop Codex Cursor VS Code

run in your terminal

claude mcp add opedd-mcp --transport http https://mcp.opedd.com/mcp

~/Library/Application Support/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "opedd-mcp": {
      "url": "https://mcp.opedd.com/mcp"
    }
  }
}

~/.codex/config.toml

[mcp_servers.opedd-mcp]
url = "https://mcp.opedd.com/mcp"

.cursor/mcp.json

{
  "mcpServers": {
    "opedd-mcp": {
      "url": "https://mcp.opedd.com/mcp"
    }
  }
}

.vscode/mcp.json

{
  "mcpServers": {
    "opedd-mcp": {
      "url": "https://mcp.opedd.com/mcp"
    }
  }
}

This one needs environment variables set before it will start: OPEDD_BUYER_EMAIL (Your email — default buyer identity for purchases), OPEDD_PAYMENT_METHOD_ID (Stripe PaymentMethod id (pm_...) for autonomous per-article purchasing), OPEDD_BUYER_TOKEN (Buyer API token (opedd_buyer_live_*) — enables licensed content retrieval), OPEDD_ACCESS_KEY (Enterprise access key (ent_*) — enables bulk feed tools), OPEDD_BUYER_JWT (Buyer portal session JWT — enables account, audit, compliance + EU AI Act attestation tools), OPEDD_PUB_BEARER (Publisher API key (opedd_pub_*) — enables publisher content push + listing tools). The author declared them in the registry entry; get the values from the project itself.

Available tools 18

Read directly from the server with tools/list, grouped by what they act on. If a tool disappears, we record the date.

content

get_content

Retrieve the full body of a licensed article using a buyer API token (opedd_buyer_live_* canonical; opedd_buyer_test_* for sandbox). Requires OPEDD_BUYER_TOKEN env var (create one at opedd.com/licenses after purchasing). Works for per-article licenses (token scoped to that article) and archive licenses (token covers all publisher content). The publisher must have content delivery enabled and must have pushed content for the article. Phase 11 M2 RAG-extended shape: response includes 7 RAG-essential metadata fields — author, language, word_count, content_hash, image_urls, canonical_url, tags. On pre-2026-05-14 historical articles, optional fields (author/language/image_urls/canonical_url/tags) may be NULL. NULL means 'data unavailable for this article', NOT 'explicitly empty' — treat as data-missing when filtering; do not interpret as anti-match.

search_content

Full-text search across everything licensable on Opedd (public, no key needed). Ask in plain words or use quotes for phrases and -word to exclude. Returns ranked matches with the publisher, prices, word count and a short description snippet (never the body). Use it to answer 'does Opedd have coverage on X', then lookup_content or get_content for a specific article.

publisher

list_publisher_content

List all licensable articles for the authenticated publisher (requires OPEDD_PUB_BEARER, or legacy OPEDD_API_KEY). Returns articles with titles, descriptions, pricing, and sales statistics. Set include_body=true to read back the STORED article text exactly as licensed buyers receive it (this is how you check that a push_content call stored what you meant; bodies are truncated to 8,000 characters per article, page size 20, paginate with cursor). Use article IDs from this list to purchase licenses via purchase_license.

publisher_directory

Browse the public Opedd publisher catalog via GET /publisher-directory. Returns paginated publishers with article counts, pricing (per-article + annual + monthly-forward-feed), plan, and sample articles (RAG-extended metadata). **The primary discovery surface for AI labs to find Opedd-licensable publishers** — distinct from `browse_registry` (which lists issued LICENSES, not publishers). Filter by category (case-insensitive substring), min_articles, or verified status. Public no-auth — useful pre-purchase scoping before buyers commit to enterprise-license POST.

purchase

purchase_enterprise_license

Purchase a bulk enterprise license covering multiple publishers (Phase 10). Returns a Stripe client_secret for payment completion + the enterprise_license_id. After payment, an ent_* access key is emailed to buyer_email. Scopes: 'custom' (pass-through publisher_ids), 'platform_wide' (auto-resolve all opted-in publishers), 'filtered' (Phase 10 filter_rules). License tiers: 'rag' (= ai_retrieval), 'training' (= ai_training, flat-fee not metered), 'inference' (= ai_retrieval), 'full_ai' (writes both retrieval + training records). The buyer must accept the Opedd Master Services Agreement (opedd.com/terms) before purchase — set terms_accepted=true to record it.

purchase_license

Purchase a content license from the Opedd protocol using a Stripe payment method. Returns a license key (format: OP-XXXX-XXXX) and a certificate URL. The buyer receives a Handshake Email with their license key. Set OPEDD_BUYER_EMAIL and OPEDD_PAYMENT_METHOD_ID env vars to avoid passing them on every call. License types: 'human' = republication rights, 'ai' = training dataset rights, 'ai_inference' = inference/RAG rights.

article

article_53_attestation

Issue a signed JWT attesting to EU AI Act Article 53 compliance for a specific license via GET /eu-ai-act/article-53-attestation (Phase 12 Wave 1 W1.4). Returns a freshly-signed HS256 JWT regulators can verify offline against the canonical signing key. Embeds: license context, usage-count over the attestation window, the most-recent Tempo Merkle root, and canonical claims (iss/sub/iat/exp/jti/aud). **The artifact AI labs hand to legal/procurement for EU AI Act Article 53(1)(d) transparency-obligation evidence.** Per INVARIANTS.md W1.6: this attests to EU AI Act Article 53 ONLY (buyer-side GPAI-model-provider transparency obligation). It does NOT discharge a publisher's CDSM Article 4(3) reservation obligation — that lives on the rsl_get tool (jsonld=true variant). Never conflate. Optional `content_id` scopes the attestation to one article; default is license-wide. Window cap: 365 days. Auth: an audit-scoped buyer API key (OPEDD_BUYER_TOKEN) or OPEDD_BUYER_JWT.

audit

get_audit_events

Browse per-event audit rows for the authenticated buyer via GET /buyer-audit (Phase 9.x). Each row carries license_terms + Tempo on-chain attestation (merkle_root + inclusion_proof when blockchain_status='confirmed'). Optional filter by event_type ('content_access', 'bulk_content_access', 'compliance_report_generated'). Window cap 30 days (vs 90-day cap on get_compliance_dossier). Attestation inclusion proof is included on every row by default — no separate flag needed (M6.4 consolidation per founder ratification: tools 4 + 6 merged into one cleaner mental model). Auth: an audit-scoped buyer API key (OPEDD_BUYER_TOKEN — create at opedd.com/buyer, Account → API keys) or OPEDD_BUYER_JWT.

browse

browse_registry

Browse the public Opedd license registry. Returns recently issued licenses and licensable content. Filter by publisher_id to explore all content from a specific publisher. Filter by article_id to see all licenses issued for a specific article.

buyer

get_buyer_account

Fetch the authenticated buyer's account profile + masked API key list via GET /buyer-account. Returns the enterprise_buyers row (contact_email, buyer_org, created_at, etc.) plus a list of all buyer-side API keys with masked prefixes (NEVER plaintext post-issuance — only the 12-char key_prefix is returned, e.g. 'opedd_buyer_'). Use cases: post-signup verification ('what was just issued to me?'), buyer dashboard mental model ('what licenses do I currently hold?'), audit prep ('show me the key list before rotation'). For full mid-lifecycle license details (filter_rules, billing, payouts), buyers consult the buyer portal at opedd.com/buyer. Requires OPEDD_BUYER_JWT (JWT-only by design: this surface manages API keys, and a key must never mint keys).

compliance

get_compliance_dossier

Generate a procurement-defense compliance dossier via GET /buyer-compliance-report (Phase 11 M4). Per-row dossier shape: 25+ fields including 17 RAG-essential article fields + full license_terms + on_chain_attestation block. Bulk envelopes fan out into per-article rows by iterating metadata.article_ids[]. Self-audit invariant: every successful call writes one license_events row with event_type='compliance_report_generated' BEFORE returning. Window cap: 90 days per call (vs 30-day cap on get_audit_events). For annual audits, paginate via _meta.next_cursor across 4 quarterly windows. Compliance framework anchors (boolean flags) map to EU AI Act Article 53, CDSM Article 4(3), on-chain attestation, TDM reservation. Auth: an audit-scoped buyer API key (OPEDD_BUYER_TOKEN) or OPEDD_BUYER_JWT.

detect

detect_platform

Detect the content platform behind a URL via POST /detect-platform (Phase 12 Wave 3 W3.1). Public no-auth lookup. Given a URL, identifies what platform powers it (Substack / Beehiiv / Ghost / Medium / Brevo / custom) and returns the suggested onboarding workflow. Hostname-detectable platforms (Substack subdomain, Beehiiv suffix, etc.) resolve in milliseconds; custom domains may take ~few seconds while the detector probes well-known platform endpoints in parallel. Returns: {platform, confidence, archive_method, forward_method, required_credentials, instructions}. The archive_method + forward_method fields are the two onboarding-workflow inputs Opedd's setup wizard reads (one for historical content backfill, one for new-content forward stream). instructions is human-readable operator copy explaining the inferred path.

feed

list_feed

List articles from a buyer's licensed catalog via GET /enterprise-license (Phase 10 + 11). Content contract: flat-fee scopes (custom/platform_wide) include full content_body; METERED (filtered-scope) keys get a discovery-only feed — content_body is null and content_access is 'metered_per_call'; fetch article text via get_content (each retrieval is billed). Returns JSON-format response with paginated articles. Use `since` (ISO 8601) for delta-feed polling — only articles published after the timestamp. Use `cursor` for pagination across pages. Requires OPEDD_ACCESS_KEY (ent_* enterprise access key). For larger bulk corpus pulls, use stream_feed_ndjson (up to 1000 articles per call vs 200 here).

lookup

lookup_content

Look up a piece of content on the Opedd registry by URL. Returns the article title, publisher, available license types, and pricing (human republication price and AI training/inference price). Always call this first to check if content is licensable and what it costs.

push

push_content

Push your published articles to Opedd so they can be licensed to AI buyers (requires OPEDD_PUB_BEARER — your opedd_sk_ publisher key). Send 1–100 articles per call; batch larger back-catalogues into multiple calls. Each article needs title, url, and html_body — everything else is optional (published_at defaults to now). This is the supply-side companion to list_publisher_content: use it to onboard your archive or push new content with no code, straight from your AI assistant.

rsl

rsl_get

Fetch a publisher's RSL Standard manifest via GET /rsl-manifest (Phase 12 Wave 1 W1.1). Public no-auth endpoint — discovery surface for AI agents/crawlers wanting to know what's licensable from a publisher BEFORE going through the buyer-account signup flow. Returns the 4 canonical license types (ai_retrieval, ai_training, human_per_article, human_full_archive) the publisher has opted into, plus the EU CDSM Article 4(3) opt-out posture (`tdm_reservation`). Set `jsonld: true` to request the JSON-LD shape with embedded HMAC-SHA256 signed receipt over the CDSM Article 4(3) reservation state + `tdm:reservationSignedAt` timestamp — regulators can post-hoc verify the reservation was the claimed value at the claimed time. Default `jsonld: false` returns the raw RSL Standard JSON manifest. Per INVARIANTS.md W1.6: this is the PUBLISHER-side CDSM Article 4(3) declaration surface. It is NOT an EU AI Act Article 53 attestation (which is buyer-side, JWT-auth, via article_53_attestation tool).

stream

stream_feed_ndjson

Bulk-export a buyer's licensed catalog via GET /enterprise-license?format=ndjson (Phase 11 M3). Returns up to 1000 articles per call (collected from line-delimited JSON wire format). Same per-scope content contract as list_feed: METERED (filtered-scope) keys export metadata only (content_body null, content_access 'metered_per_call') — use get_content for article text. Each article emits one usage_records row (analytics-only sentinel 'bulk-export:<request_id>:<article_id>' — not metered-billable per the revenue-model bifurcation invariant). Use `since` (ISO 8601) for delta-feed. Use `cursor` to paginate beyond 1000. Backend supports 5000 articles per call; the MCP cap is 1000 for transport reasonability. Real bulk-ingest pipelines should use the Python SDK (pip install opedd) directly — not via MCP. Requires OPEDD_ACCESS_KEY (ent_*).

verify

verify_license

Verify the authenticity of an Opedd license key. Returns license details including: article title, publisher, license type, issue date, amount paid, buyer info, and blockchain proof status. Use this to confirm a license is valid before using licensed content.

Endpoints

URL	Transport	State	Latency	Checked
https://mcp.opedd.com/mcp	streamable-http	answering	536 ms	1 min ago

Alternatives to Opedd — Licensed Content for AI

same job, measured the same way

Context Relay

by chughes113

Compact, citation-verifiable public web context for AI agents, paid per use with x402.

2 tools answering

Agentseal

by joeybrar

Verifiable action logs for AI agents. Every action is recorded in a SHA-256 hash chain.

33 installs/wk local only

Kasbah MCP

by al-adnane

Governance layer for agentic AI — signed, verifiable receipts for every agent action.

55 installs/wk local only

OpenWorkProof

by dengyier

Verifiable execution for AI agents: Ed25519-signed work contracts and audit trails.

189 installs/wk local only

Zcash MCP

by zk-nd3r

Zcash shielded operations for AI agents. Memo decoding, attestation, proof verification.

50 installs/wk local only

VerifiedState Memory

by verifiedstate

Verified memory for AI agents. Signed assertions, billing attestation, session continuity.

answering

mdflow — Context OS for AI Coding Agents

by yubinbin32-ops

Context OS for AI coding agents: task-scoped AST context, verified mutation, and rollback.

local only

Omitly MCP

by omitly

Omitly's local, verifiable PDF redaction for AI agents — your documents never leave your device.

429 installs/wk local only

Opedd — Licensed Content for AI — questions

Answers built from our own checks of this server.

What can Opedd — Licensed Content for AI do?

It exposes 18 tools, read directly from the server on our last check. Among them: article_53_attestation, browse_registry, detect_platform, get_audit_events, get_buyer_account, get_compliance_dossier and 12 more. The full list with descriptions is on this page — we take it from the server itself via tools/list, not from a README. How MCP servers expose tools in the first place →

What is Opedd — Licensed Content for AI mostly used for?

Its tools cluster around publisher, purchase and content. That is what this server is built to work with — the grouping comes from the actual tool names, not from a category we assigned.

Is Opedd — Licensed Content for AI working right now?

We send a real MCP handshake every 15 minutes. Over the last 24 hours 69 of 92 checks got a reply (75.0%), average response time 564 ms. The bar chart above shows every period we have measured.

How do I connect Opedd — Licensed Content for AI?

Copy the ready config from this page — we generate it for Claude Code, Claude Desktop, Codex, Cursor and VS Code, each with the file path that client actually reads. It is a remote server, so there is nothing to install — the client connects to the address.

Does Opedd — Licensed Content for AI need an API key?

No. Opedd — Licensed Content for AI completed a full MCP handshake with us as an anonymous client and listed its tools without asking for anything. All 18 of them are readable on this page. This is what we observed, not what the docs claim.

How fast is Opedd — Licensed Content for AI?

It answers our handshake in 564 ms on average, which is faster than 23% of all working MCP servers we measure. That is on the slow side — worth knowing if the tool sits inside an interactive loop. The comparison comes from our own checks across the whole registry, every 15 minutes.

How many people use Opedd — Licensed Content for AI?

The npm package opedd-mcp was installed 496 times in the last week. Week over week that is +67%. We show installs rather than GitHub stars on purpose: a star is a bookmark, an install is someone actually running it.

Is Opedd — Licensed Content for AI open source?

Yes — it is published under the MIT licence, written in TypeScript and 1 stars on GitHub. The source link is on this page, so you can read exactly what it does with your data before you connect it.