---
title: "MPP Ecosystem and Registry"
type: concept
tags: [ecosystem, sdk, methods, crypto, fiat, emerging]
created: 2026-08-10
updated: 2026-08-10
sources: ["raw/github_doc-readme-md-3.md"]
confidence: medium
mpp_snapshot: "2026-08-10"
---

## Definition

The MPP ecosystem is the broader set of third-party and official software — SDKs, payment-method plugins, framework integrations, infrastructure, CLIs, middleware, and live services — built around the Machine Payments Protocol, beyond the core spec repository (`mpp-specs`) and the official Rust SDK (`mpp-rs`). It is characterized here through `awesome-mpp` (`github.com/mbeato/awesome-mpp`), a community-maintained "awesome list" that self-describes as "the MPP registry — 100+ Machine Payments Protocol tools, SDKs, services, and payment methods across 15+ chains," billing itself as "the definitive directory for Stripe + Tempo agent payments." It is explicitly a **community registry** (maintained by a third party, `mbeato`, not by Tempo or Stripe directly), separate from the official `mpp` repository that hosts mpp.dev's own documentation and service directory.

## How It Works

`awesome-mpp` organizes the ecosystem into ten top-level categories: Protocol and Specs, SDKs, Payment Methods, Framework Integrations, Infrastructure and Proxies, Agent Tools and CLIs, Middleware and Extensions, Services, Community Projects, and Tempo Blockchain, plus a closing Resources section. Community Projects is itself subdivided into Agent Frameworks, MCP Bridges, Applications, and Demos and Examples. Contributions are accepted via a `CONTRIBUTING.md` process, consistent with the standard "awesome list" convention (curated, PR-driven, community-submitted).

### Category landscape (not exhaustive — see the raw README for the full entry list)

- **Protocol and Specs**: points back to `mpp-specs` (the official RFC-style spec repo), `mpp` (the protocol docs site and service registry), and the IETF Internet-Draft (`draft-ryan-httpauth-payment`, co-authored by Brendan Ryan at Tempo and Jeff Weinstein at Stripe).
- **SDKs**: split into *Official* (`mppx` for TypeScript with Hono/Express/Next.js middleware and reverse-proxy support, `pympp` for Python, `mpp-rs` for Rust, `tempo-go`/`tempo-ts` for Tempo-specific tooling) and *Community* (a Ruby port, a community Go SDK, a FastAPI middleware, an Elixir implementation, a .NET SDK, and a Dart SDK) — i.e. the official language coverage (TS/Python/Rust/Go/Ruby, matching the mpp-specs README's SDK list) is supplemented by community reimplementations in additional ecosystems (.NET, Elixir, Dart).
- **Payment Methods**: confirms the protocol's payment-method-agnostic design in practice — plugins exist for Solana (six separate listed projects, including an official Solana Foundation SDK), Lightning (three listed projects, including Spark- and LND/NWC-based ones), and a long tail of "Other Chains" covering Sui, Stellar, XRP Ledger, Abstract, Movement, TON, Algorand, Avalanche, MultiversX, MegaETH, SKALE, Zcash, Monad, Canton, and cross-chain routers (e.g. via Squid Router) — this is the concrete evidence behind the "15+ chains" claim in the README's own footnote/tagline.
- **Framework Integrations**: built-in middleware for Hono, Express, Next.js, Elysia, Bun.serve, and Deno.serve ships inside `mppx` itself; community integrations extend this to e.g. Next.js App Router combined auth (MPP + x402 + API-key) and AWS infrastructure glue.
- **Infrastructure and Proxies**: standalone reverse proxies (`mppx-proxy`), a Cloudflare Workers proxy maintained by the Tempo team itself (`mpp-proxy-cf`), a transaction explorer/service-discovery site (`mppscan.com`), and paid-infrastructure examples like an MPP-powered VPS host and a GitHub REST API proxy gated by MPP payments.
- **Agent Tools and CLIs**: CLI wallets and frameworks for agents/humans (`incur`/`incur-rs`), an official Tempo "agent skill pack," debugging tools (`MPP-Inspector`), and a cluster of dual-protocol tools that bridge MPP with the competing/complementary `x402` protocol (e.g. `x402-proxy`, `402Router`, `APIbase`) — signaling that in practice, agent-payment tooling in this ecosystem often supports MPP and x402 side by side rather than exclusively one or the other.
- **Middleware and Extensions**: rate limiting, token-gating, tax computation, trust/reputation layers, KYC-style "Know Your Agent" screening, spend-verification/budget-cap tooling, and — again — a large cluster of x402-adjacent projects (Coinbase's own `x402` repo is listed here as a related/complementary protocol implementation, not an MPP component).
- **Services**: split into *First-Party* (services with built-in MPP support, e.g. pay-per-call API bundles, pay-per-request image generation, voice/video AI, browser automation, C2PA content-provenance verification, code execution sandboxes, GPU compute) and *Proxied via Tempo* (third-party APIs made payable through Tempo's `mpp.tempo.xyz` proxy without native MPP support — spanning AI/ML providers like Anthropic, OpenAI, Google Gemini, and Mistral; data/search providers like Exa, Firecrawl, and Brave Search; developer tools like Deepgram and Mapbox; and business, travel/weather, and generic "Abstract APIs" categories).
- **Community Projects**: the largest and most heterogeneous category — agent frameworks and agent-to-agent marketplaces, MCP bridges that turn MCP server tools into paid endpoints (e.g. `mpp-mcp`, `mpp-bundler` as a Claude Code plugin for scaffolding MPP billing, `402index-mcp-server` for discovery across "15,000+ paid API endpoints"), and a long tail of applications and hackathon demos (DoorDash/Shopify ordering agents, NBA micro-betting, voice-as-a-service, agent-to-agent settlement engines and even Solidity contracts for it).
- **Tempo Blockchain**: the underlying chain infrastructure that Tempo-flavored MPP methods settle on — the chain itself, a frontend apps monorepo, a Foundry fork, Solidity standard libraries, and a Ledger hardware-wallet plugin.
- **Resources**: documentation (mpp.dev, docs.tempo.xyz) and articles (Stripe's own MPP announcement blog post, Tempo's mainnet-launch post introducing MPP, and Stripe's broader "Agentic Commerce Solutions" post) situating MPP within Stripe's and Tempo's larger agentic-commerce strategy.

## Key Parameters

- **Scale claim**: "100+" tools/SDKs/services and "15+ chains," per the README's title tagline and its own self-listing entry.
- **Launch context** (README footnote): MPP is described as launched **March 2026**, an open HTTP payment standard created by Stripe and Tempo Labs, using HTTP 402 with an extensible challenge-credential-receipt flow; payment-method agnostic (stablecoins, credit cards, Lightning, 15+ chains); supports one-time charges, pre-authorized-spending sessions, and streaming.
- **Official vs. community distinction**: the SDKs and Payment Methods sections both explicitly separate "Official" (Tempo/Stripe/partner-maintained, e.g. Solana Foundation's own SDK) from "Community" (independently authored, third-party) entries — a useful signal for trust/maintenance-risk when picking a dependency from the list.
- **Cross-protocol overlap**: a large fraction of "Middleware and Extensions" and "Agent Tools and CLIs" entries are dual- or multi-protocol (MPP + x402, or MPP + x402 + L402 + other agent-payment schemes like Google AP2, Visa TAP, Mastercard Agent Pay), reflecting that x402 (Coinbase's competing/adjacent HTTP-402 payment protocol) is the most commonly paired protocol in this ecosystem, not a one-off.

## When To Use

- Consult `awesome-mpp` when looking for a payment-method plugin for a chain not covered by the official `mpp-rs`/`mppx` SDKs (e.g. Solana, Stellar, Lightning, or one of the long-tail chains) rather than building one from scratch.
- Consult it when choosing infrastructure to gate an existing API/service with MPP (proxies, framework middleware) without writing custom 402-handling code.
- Consult it for prior art before building new agent-payment tooling (CLIs, MCP bridges, trust/reputation layers) — the "Community Projects" and "MCP Bridges" subsections in particular show many teams have already built overlapping pieces.
- Treat entries as a discovery starting point, not a certification — see Risks & Pitfalls below.

## Risks & Pitfalls

- This is a **community-maintained registry**, not an official Tempo/Stripe directory — inclusion in `awesome-mpp` does not imply endorsement, security review, or maintenance guarantees by the protocol's authors. The official service directory lives in the separate `mpp` repository / mpp.dev, referenced but not duplicated here.
- Confidence for this material is **medium**: it is grounded in a single source (the `awesome-mpp` README itself), which is inherently a self-reported, PR-driven listing — entry descriptions are one-line self-summaries from each linked project, not independently verified by this wiki.
- Many "Community" and third-party entries are hackathon-scale or early-stage projects (the README's own Demos/Examples and hackathon-tagged entries make this explicit); do not treat listing density in a category as a signal of production readiness.
- The ecosystem heavily overlaps with the separate **x402** protocol (Coinbase-originated) — several tools listed under MPP categories are actually dual-protocol or x402-primary with MPP as a secondary integration. When evaluating a tool from this list, check which protocol(s) it actually implements natively versus which it merely proxies or bridges to.
- "Proxied via Tempo" services (e.g. Anthropic, OpenAI, Exa) are not native MPP integrations — they are made payable through Tempo's own `mpp.tempo.xyz` proxy layer, which is a distinct trust and reliability boundary from a service that implements the `Payment` scheme itself per [[concepts/payment-http-auth-scheme]].

## Related Concepts

- [[concepts/mpp-overview]] — the protocol this ecosystem builds on top of, including the official SDK list this registry supplements
- [[concepts/using-mpp]] — the official Rust SDK (`mpp-rs`) covered in depth elsewhere; this page covers everything around it in other languages and layers
- [[concepts/payment-discovery]] — the protocol-level discovery mechanism that registry/catalog tools like `mppscan.com` and the catalog-client pattern build on
- [[concepts/extending-mpp]] — how a new entry in this ecosystem (e.g. a new chain's payment-method plugin) would formally register itself as a spec

## Sources

- raw/github_doc-readme-md-3.md (`mbeato/awesome-mpp` README: full category listing, SDK official/community split, payment-method chain coverage, services split, footnote description of MPP's launch and design)