On this page
Stripe Projects: What They Are and 5 Use Cases for AI Builders
Stripe Projects gives AI agents scoped API keys, spending limits, and a CLI for provisioning services across 40+ providers. Here's how it works...
AI agents can now provision databases, upgrade API plans, and pay for cloud services, all without a human having to click "approve." Stripe Projects, launched in developer preview, is the infrastructure layer making this possible. It gives agents scoped financial identities, hard spending limits, and a unified CLI for provisioning services across 40+ providers.
If you're building AI-powered SaaS, multi-agent systems, or coding agents that need to interact with real-world services, Stripe Projects changes what's practical.
Key Takeaways
Stripe Projects is a CLI-based provisioning layer that lets developers and AI agents add, manage, and pay for cloud services (hosting, databases, auth, AI models) from the terminal (Stripe, 2025)
It solves the "agent identity problem" — giving AI agents scoped API keys, hard spending limits, and auditable transaction logs without exposing your full Stripe account
Stripe's official MCP server exposes 30+ billing operations as agent-callable tools, making it possible to build fully autonomous billing pipelines
For multi-tenant SaaS builders, Projects replaces the fragmented setup flow with deterministic, version-controlled service provisioning
What Are Stripe Projects?
Stripe Projects is a Stripe CLI plugin that standardizes how developers (and AI coding agents) provision, configure, and pay for third-party cloud services. Instead of jumping between the Vercel dashboard, Supabase console, and Clerk admin panel, you run stripe projects add from the terminal and Stripe handles credential fetching, encryption, and billing.
Each project lives in a .projects/ directory inside your codebase and contains three things: a state.json file tracking, which services are provisioned, an encrypted vault for credentials, and auto-generated agent skill files that coding agents can use to drive the workflow.
The scope is substantial. At launch, Stripe Projects supports 40+ providers across hosting (Vercel, Railway, Render, Fly.io, Cloudflare), databases (Neon, Supabase, PlanetScale, Turso, Upstash), authentication (Clerk, Auth0/Okta, WorkOS), AI (OpenRouter, Hugging Face, ElevenLabs, Chroma), analytics (PostHog, Amplitude, Mixpanel), and observability (Sentry). It's a unified service catalog with a single payment method attached.
Stripe Projects — Provider Distribution by Category Hosting: 8 providers 8 Hosting Databases: 6 providers 6 Databases Auth: 5 providers 5 Auth AI/ML: 7 providers 7 AI/ML Analytics: 5 providers 5 Analytics Other: 9+ providers 9+ Other 0
Source: Stripe Projects Catalog, April 2025. 40+ providers available in Developer Preview.
Our finding: The developer preview positions Stripe Projects as a direct response to the fragmentation that makes agent-driven DevOps impractical. When an agent needs a database, it shouldn't need a human to create an account, navigate a UI, copy API keys, and paste them into
.env. Projects makes that flow deterministic and auditable.
The credential model is worth understanding: when you add a payment method via stripe projects billing addStripe creates a Shared Payment Token. Providers receive scoped billing credentials, but your underlying card details are never shared with them. When you upgrade from the free tier to a paid plan, Stripe uses this token instead of asking you to re-enter payment info on each provider's site.
What Problems Do Stripe Projects Solve for AI Builders?
Three problems make agent-driven infrastructure impractical without something like Projects.
First, there's no standard protocol for agents to provision services. Every provider has a different API, a different auth model, and a different billing flow. An agent that works with Vercel doesn't automatically work with Neon. Stripe Projects defines a co-designed integration protocol: providers implement it once, and every agent that speaks "Projects" can provision that service.
Second, agents lack financial identity. Before Projects, giving an agent the ability to spend money meant handing it your Stripe secret key with broad permissions. That's terrifying. Projects introduce scoped API keys tied to a specific Project, with hard spending limits, merchant allowlists, and optional human-in-the-loop approval thresholds. Each transaction is logged with attribution. You know which agent spent what, when, and on which provider.
Third, development environments are not portable. A new team member joining your project spends hours creating accounts, copying credentials, and configuring local state. With Projects, the entire service stack is declarative. stripe projects env --pull brings down every credential, and state.json means the provisioning itself is version-controlled.
So why does this matter for AI builders specifically? Agents that can't interact with infrastructure can't ship. Projects give them the primitives to do both.
5 Key Use Cases for AI Builders
1. Autonomous Agent Provisioning
The most immediate use case is for coding agents to provision their own infrastructure. Stripe Projects writes agent skill files into your project directory when you run stripe projects init. These files describe available commands, provider options, and billing tiers in a format agents can parse.
In practice, this means you can tell Claude Code or Cursor: "Add a Postgres database and Clerk auth to this project, use free tiers." The agent reads the skill file, runs stripe projects catalog to find matching services, provisions them, and returns the credentials. You never touch a dashboard.
# What the agent runs:
stripe projects init my-saas
stripe projects link vercel
stripe projects add neon/database
stripe projects add clerk/auth
stripe projects add posthog/analytics
stripe projects env --pull
This works because Projects exposes deterministic commands with predictable outputs. The agent doesn't need to parse HTML dashboards or reverse-engineer API endpoints. It runs CLI commands and reads structured state.
2. Multi-Tenant SaaS Infrastructure
For SaaS builders managing separate environments per customer or per deployment stage, Projects solves the problem of configuration sprawl. Create distinct Projects for development, staging, and production. Each has an independent state, credentials, and billing:
stripe projects init myapp-dev
stripe projects init myapp-staging
stripe projects init myapp-prod
The state.local.json file handles per-developer overrides, so teammates can use their personal provider accounts in dev while production uses the team's shared accounts. When onboarding a new engineer, they clone the repo, run stripe projects init, link their personal accounts, and start building. No credential scavenger hunt.
For agencies and platforms managing per-client infrastructure, Projects provides natural tenant isolation. Each client gets a Project with scoped credentials. If a client's agent has access to Project A, it can't touch Project B's resources.
3. Agentic Billing Workflows
Stripe published a dedicated guide for this pattern, and it's where the Agent Toolkit shines. The @stripe/agent-toolkit package provides pre-built function-calling integrations for OpenAI Agents SDK, LangChain, CrewAI, and Vercel AI SDK. Combined with Stripe's MCP server at mcp.stripe.com, agents get 30+ callable billing operations:
from stripe_agent_toolkit.openai.toolkit import create_stripe_agent_toolkit
toolkit = await create_stripe_agent_toolkit(
secret_key="rk_live_scoped_to_project"
)
tools = toolkit.get_tools()
# Agent now has: create_customer, create_subscription,
# list_invoices, create_payment_intent, etc.
The workflow architecture Stripe recommends: agents provision customers and subscriptions programmatically, listen for webhook events (invoice.payment_failed, customer.subscription.deleted), and trigger downstream actions — retrying failed payments, offering retention discounts, or escalating to a human when thresholds are met.
According to Stripe's 2025 agentic billing guide, this pattern turns subscription lifecycle management from a multi-system integration nightmare into a single-agent loop with built-in audit logging (Stripe, 2025).
The open-source toolkit repo at github.com/stripe/agent-toolkit has 1,433 stars and 40 contributors as of April 2025, and supports both TypeScript and Python.
4. Multi-Agent Orchestration
This is where Projects gets architecturally interesting. In a multi-agent system, different agents need different spending scopes. Your infrastructure agent should be able to provision databases but not cancel customer subscriptions. Your billing agent needs read-write access to invoices, but shouldn't deploy code.
Projects map cleanly to this model:
Agent | Project Scope | Permissions |
|---|---|---|
Infra Agent | Project | Provision DBs, hosting, storage |
Billing Agent | Project | Read/write invoices, subscriptions |
Monitoring Agent | Project | Read-only analytics, alert config |
Orchestrator | Cross-project read | Coordinate + escalate |
Each agent gets a Project with scoped API keys (rk_*) and hard spending limits. The orchestrator coordinates but doesn't have transaction authority itself — separation of concerns enforced at the API level. All activity is logged per agent, per project, with full attribution in the Stripe dashboard.
5. AI-First Development Environments
For teams building with AI-native toolchains, the .projects/ directory becomes part of the repo's developer contract. When you clone a repo that uses Projects, you get not just the code but the infrastructure specification. Running stripe projects init reads the existing state.json and provisions the exact services the project needs.
The stripe projects llm-context The command takes this further. It generates a combined context file that includes all service configurations, available commands, and provider documentation. Feed this into your coding agent, and it will understand the full infrastructure surface without you having to explain it.
Stripe Projects vs. Stripe Connect: What's the Difference?
This question comes up constantly because both involve multi-account Stripe architectures. They serve fundamentally different purposes:
Stripe Projects | Stripe Connect (Custom) | |
|---|---|---|
Primary user | AI agents | Human sellers/merchants |
Use case | Agents are spending money on cloud services | Platforms collecting payments on behalf of users |
Auth model | Scoped API keys per Project | API calls with |
Spending controls | Hard limits, merchant allowlists, approval thresholds | Platform controls payouts; fraud liability on the platform |
Setup complexity | Moderate (CLI-driven) | High (custom onboarding UI, KYC, dashboard) |
Agent-native API | MCP server + Agent Toolkit | None — build everything manually |
Dashboard access | Parent account sees all Project activity | Connected accounts have zero dashboard access |
The key insight: Connect is for platforms paying humans. Projects are for platforms empowering agents. They're not mutually exclusive. A marketplace could use Connect for seller payouts while using Projects to let internal AI agents autonomously manage infrastructure procurement. Same parent Stripe account, different scoping models, different authorization surfaces.
How Do AI Agents Pay for Services Through Stripe Projects?
The payment architecture has three layers.
Layer 1 — The MCP Server. Stripe's official Model Context Protocol server at mcp.stripe.com (or self-hosted via npx -y @stripe/mcp) exposes Stripe API operations as callable tools. Agents in Claude Code, VS Code, Cursor, or ChatGPT can invoke create_payment_intent, create_subscription, list_products, and 27+ other operations directly from their reasoning loop.
The npm package @stripe/mcp (v0.3.3) sees roughly 19,600 weekly downloads, which tells you agent toolchain adoption is real and accelerating (npm, 2025).
Layer 2 — The Agent Toolkit. For framework-native integration, @stripe/agent-toolkit (TypeScript) and stripe-agent-toolkit (Python) Provide turnkey function-calling modules for OpenAI, LangChain, CrewAI, and Vercel AI SDK.
Stripe Agent Toolkit — Framework Support Distribution 4 Frameworks OpenAI SDK LangChain CrewAI Vercel AI SDK
Source: github.com/stripe/agent-toolkit, April 2025.
Layer 3 — Security Controls. Stripe strongly recommends restricted API keys (rk_*) for agent use, and Projects enforces this with additional guardrails:
Hard spending limits enforced at the API level (not just notifications)
Allowlisted merchants and products (the agent can buy from Neon but not from an unknown provider)
Full transaction logging with agent attribution
Optional human-in-the-loop thresholds (charges above $X require approval)
Encrypted credential vault with automatic rotation support
The Shared Payment Token model means the agent never sees your payment details. It requests an upgrade; Stripe processes the charge against the token; the provider gets scoped billing credentials. Your credit card number stays opaque to both the agent and the provider.
How to Get Started with Stripe Projects
Stripe Projects is in Developer Preview. Access requires signing up at projects.dev. Once you're in:
# 1. Install the plugin
stripe plugin install projects
# 2. Create your first project
stripe projects init my-first-project
# 3. Browse what's available
stripe projects catalog
# 4. Add services you need
stripe projects add neon/database
stripe projects add clerk/auth
stripe projects add vercel/project
# 5. Add a payment method (for paid tiers)
stripe projects billing add
# 6. Pull credentials to .env
stripe projects env --pull
# 7. Check status anytime
stripe projects status
The payment handoff (Shared Payment Token) currently works in the US, EU, UK, and Canada for supported providers. Billing is usage-based: you pay providers directly for their plans. Stripe Projects itself is a free tool.
Current limitation: As a Developer Preview, the catalog is expanding incrementally. Not every provider has implemented the integration protocol yet. Check
stripe projects catalogfor the latest availability, and plan for some services to still require manual provisioning. In our experience, the AI and database categories are the most mature right now.
Frequently Asked Questions
Do I need a Stripe account to use Stripe Projects?
Yes. Projects run within your existing Stripe account and inherit its billing infrastructure. You'll need a standard Stripe account — the same one you'd use for processing payments — and the Stripe CLI installed.
Is Stripe Projects meant to replace infrastructure-as-code tools like Terraform?
No. Projects focus on SaaS service provisioning (database-as-a-service, auth-as-a-service, AI model APIs), not raw cloud infrastructure (VMs, VPCs, load balancers). It's complementary. You might use Terraform for AWS and Projects for the application-layer services on top.
Can I use Stripe Projects with existing projects, or only new ones?
You can initialize Projects in any codebase with stripe projects init. If you already have services running, use stripe projects link this to associate your existing provider accounts without re-provisioning. The Project tracks state alongside your existing setup.
What happens if I exceed the spending limit on a Project?
Transactions are rejected at the API level. The agent receives an error, the charge doesn't go through, and the event is logged. You configure limits per Project; raise or lower them as your trust in the agent grows.
How does this compare to just using API keys from each provider individually?
The difference is standardization. Without Projects, each provider has its own signup flow, credential format, billing portal, and upgrade path. An agent needs custom integration code per provider. Projects collapse this into a single protocol: one CLI, one billing method, one credential model, one audit trail.
The Bottom Line
Stripe Projects represents an early but real shift toward agents as first-class economic actors. It gives AI systems their own identity layer, spending authority, and audit trail — the same primitives humans have had with corporate cards and procurement systems.
For AI builders in 2025, the practical takeaway is: if you're building agent-driven workflows that involve service provisioning or payments, the fragmentation that made this painful is being solved at the infrastructure level. Stripe's bet with Projects is that, in a world where agents write software, provisioning the software's dependencies should be agent-native, too.
