Generated banner for Stripe Apps
Generated logo for Stripe Apps

Stripe Apps

StripeOfficialPublished by Stripe

  • Skill
  • Tool integration
  • Software development
  • MIT
  • No issues found

From the author

Build, modify, or review Stripe Apps and extensions using the relevant documentation and reference guides. Use for custom Stripe Dashboard UI, stripe-app.yaml, @stripe/ui-extension-sdk, @stripe/extensibility-sdk, script extensions, extension interfaces, custom workflow actions, and apps that authenticate to Stripe or react to events. Also use when deciding whether a Stripe extension can support the user's billing or workflow requirements.
— the description by Stripe

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured approach to developing and maintaining Stripe Apps. It guides users through selecting the correct extension architecture, implementing authentication, building UI components, and managing backend services or webhooks. By leveraging bundled reference files and canonical documentation, it ensures that app development follows Stripe's best practices for security, configuration, and lifecycle management.

What it does

  • Provides guidance on selecting the appropriate Stripe extension interface.
  • Assists in building and modifying Stripe Dashboard UI components.
  • Supports the implementation of backend services, webhooks, and secret storage.
  • Helps determine the correct authentication method for Stripe API access.
  • Offers instructions for testing, debugging, and publishing Stripe Apps.
  • Clarifies the applicability of extensions for specific billing or workflow requirements.

When to use it

  • When you need to build a custom UI extension for the Stripe Dashboard.
  • When deciding between Restricted API keys, Platform keys, or OAuth for your app.
  • When implementing backend logic or handling Stripe events via webhooks.
  • When you need to store sensitive credentials securely using the Secret Store API.
  • When troubleshooting or modifying an existing Stripe App's manifest or configuration.

Advantages

  • Ensures alignment with official Stripe development patterns and security standards.
  • Reduces development time by providing clear paths to relevant documentation.
  • Helps prevent common architectural errors in app authentication and event handling.
  • Provides a consistent workflow for the entire app lifecycle from scaffolding to release.

Usage examples

“How do I determine if my Stripe App needs a backend?”
The agent will reference the backend documentation to explain that a backend is required for long-term data storage, server-side secrets, or handling webhooks, while suggesting the Secret Store API for simpler needs.
“Help me choose the right authentication type for a private Stripe App.”
The agent will compare Restricted API keys, Platform keys, and OAuth, recommending Restricted API keys as the simplest and most secure choice for private integrations.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/stripe/stripe-apps/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip stripe-apps.zip -d .agents/skills

Documentation by Stripe

Stripe Apps

Select and read the existing guidance for the user’s task. Product documentation describes what an extension can do; implementation guides describe how to build it. Before recommending an extension or writing code, load the applicable bundled reference files as well as the relevant product documentation. A link or filename in this skill isn’t a substitute for reading its contents.

For a capability question, check native Stripe features and the documented applicability and limitations of the extension. For an implementation request, create or modify working files using the selected guide. For an existing app, inspect its manifest, packages, installed SDK, and local agent instructions before deciding what to change.

Choose the relevant documentation

Use information already supplied by the user or existing app. Read <references/discovery.md> when you need to clarify the app’s requirements, and <references/extension-types.md> for an overview of app architectures. Ask only for missing information that affects the task.

Product capabilities

Use these existing product documents to determine which capability fits and whether the account has the required access. Don’t infer support from an extension’s name or the existence of a scaffold.

TaskRead
Select an extension interface and its supported implementation typesExtension points and how extensions work
Change how items are included on subscription invoicesItem handling extensions
Customize prorationsNative proration behavior and prorations extensions
Apply customer balancesCustomer balance extensions
Calculate discount amountsDiscount calculation extensions
Add an action to Stripe WorkflowsExisting workflow actions, existing custom actions, and how custom actions work
Customize another product’s behaviorFollow the selected interface’s product documentation from the extension-point catalog
Implementation guidance

The references/*.md files are bundled with this skill. After selecting the capability, load the applicable files before following their links to supporting documentation. Combine rows when an app needs multiple types. Follow the selected guide’s prerequisites, scaffolding, testing, and debugging instructions.

TaskRead
Build or modify any Dashboard UI, including drawers and full-page apps<references/ui-extensions.md>, then each selected component’s current API documentation
Author, test, or debug a script extension<references/script-extensions.md>, then the selected extension point’s implementation guide
Build a custom-action script<references/script-extensions.md> and build a custom action with a script
Build a custom-action remote functionBuild a custom action with a remote function
Build a self-hosted UI back-end or webhook service<references/backend.md> and <references/authentication.md>; also load <references/webhooks.md> when receiving Stripe events
Store app credentials with the Secret Store APIThe Secret Store API section in <references/backend.md> and store secrets, including for apps without a self-hosted back-end
Look up APIs, SDK patterns, configuration, or additional extension documentation<references/canonical-docs.md>

Use the UI reference for layout and composition, and current component documentation for import paths, props, and styling APIs. For scripts and remote functions, follow the selected extension’s documentation; UI and self-hosted back-end instructions don’t define their runtime capabilities.

Shared app lifecycle

Read these references when the corresponding task is needed. Reuse existing apps and packages; scaffold only what is missing.

TaskRead
Scaffold, build, test, preview, or upload an app<references/workflow.md>, together with the selected implementation guide
Choose authentication for access to Stripe APIs<references/authentication.md>
Receive Stripe events<references/webhooks.md>
Build a first-run setup experience<references/onboarding-ux.md> and the UI reference
Release versions, change installed permissions, or publish to the marketplace<references/publishing.md>
Submit feedback after running app toolchain commands<references/feedback.md>

Load bundled reference files

  1. Use the task tables to select every applicable bundled reference under references/, then open those files with a file-reading tool before starting the corresponding work. For example, UI with a self-hosted back-end needs both UI and back-end guidance; onboarding also needs the UI reference.

  2. Follow relevant pointers to other bundled references inside the files you load, including filenames written as code rather than links. For example, back-end guidance can require authentication guidance, and changing permissions can require publishing guidance. Use this skill’s direct links to locate those files.

  3. Read the canonical documentation required by those references. External documentation supplements the bundled guidance on workflow, layout, and other task-specific decisions.

  • Resolve references/ paths relative to this skill’s directory and bare reference filenames relative to its references/ directory. When reading the hosted skill, fetch the corresponding reference URLs relative to the skill URL.

  • Load only references relevant to the task, and reuse contents already read during the session unless they have changed. A full-stack app doesn’t require every document in the skill.

  • Read canonical pages using the available documentation tools. Prefer stripe docs when available, including for pages that require account access.

  • Use current product documentation and the installed SDK’s types for API contracts and limitations. If an example in a reference disagrees, check the version and follow the applicable canonical documentation.

  • Read any interface-specific agent instructions supplied with an existing or newly generated extension. If none are present, use the linked product and implementation guides.

  • If the documentation doesn’t establish that an extension meets a requirement, state what is unknown or unsupported before proceeding.

  • Keep the work within the user’s request. Report the changes, validation results, and remaining steps relevant to that app.

Files

references/discovery.md

Discovery interview

Discovery interview

Use these questions to resolve requirements that affect the requested work. Reuse information from the user and existing app, and skip questions that are already answered or don’t apply. Ask one unresolved question at a time, using plain language. If the requirements are clear, proceed without an interview.

Question 1 — What do you want to do?
What would you like your app to do? Pick the option that sounds closest:

1. Show something or add a custom page or experience inside my Stripe Dashboard
   (for example: a custom standalone page in the Dashboard, show a customer's loyalty points, add a "Send email" button)

2. Automatically do something when a payment or event happens
   (for example: send a confirmation email, update a spreadsheet, sync data)

3. Both — add something to the Dashboard AND react to Stripe events

4. Let merchants connect their Stripe account to my service without sharing API keys

5. Add custom logic to how Stripe calculates bills or routes payments
   (availability depends on the extension point)

6. I'm not sure — ask me more questions

Routing:

  • Option 1: UI extension. Ask Question 2.

  • Option 2: Back-end-only app. Ask Question 3. Then read backend.md, webhooks.md, authentication.md, workflow.md.

  • Option 3: Full-stack app. Resolve any unanswered UI and audience questions. Read ui-extensions.md, backend.md, authentication.md, webhooks.md, and workflow.md. Load other references only when their corresponding task applies.

  • Option 4: App-as-authentication. Read authentication.md, workflow.md.

  • Option 5: Extension interfaces. Read the extension-point catalog and the selected interface’s product documentation for applicability, supported implementation types, and current access requirements. Ask about access only if the documentation requires it and access hasn’t already been established.

  • Option 6: Ask a follow-up question: “What problem are you trying to solve? For example: tracking sales, notifying customers, connecting a third-party tool?”

Question 2 — Where do you want your app to appear? (only if UI)
Where in the Stripe Dashboard should your app show up?

1. Next to a specific customer, payment, invoice, subscription, or product
2. Everywhere in the Dashboard as a floating side panel
3. As its own full-screen page
4. In the settings area of my app (after install)
5. As a setup guide when someone installs my app
6. I'm not sure

Viewport routing:

AnswerViewport(s)
Next to a customerstripe.dashboard.customer.detail
Next to a paymentstripe.dashboard.payment.detail
Next to an invoicestripe.dashboard.invoice.detail
Next to a subscriptionstripe.dashboard.subscription.detail
Next to a productstripe.dashboard.product.detail
On any list pagestripe.dashboard.customer.list, .payment.list, etc.
Everywhere (side panel)stripe.dashboard.drawer.default
Full-screen pageFull-page app — stripe.dashboard.fullpage
Dashboard homepagestripe.dashboard.home.overview
Settingssettings viewport
Setup guide (first run)onboarding viewport

If the answer is “full-screen page”, read ui-extensions.md (full-page apps section). If the answer is “setup guide”, also read onboarding-ux.md. If “I’m not sure”, ask: “When someone opens Stripe and looks at a customer’s page — would your app show up there? Or would it be more like its own separate page?”

Question 3 — Who is this for?
Who will use this app?

1. Just me / my own Stripe account (private app)
2. Other Stripe users — I want to publish it to the marketplace

Routing:

  • Option 1: Private app. Simpler workflow — no marketplace submission needed.

  • Option 2: Public app. Will need account activation (verified email and business details). Note this in the plan.

Question 3b — Authentication type (only for public apps that need backend access)

If the user chose public/marketplace AND their app needs to access merchant data from a backend, determine the authentication type. Read authentication.md for the full comparison — restricted API keys are the recommended default unless the app specifically needs Connect-style access or OAuth.

For private apps or frontend-only apps, skip this question — restricted API keys or platform keys both work, and RAKs are simpler.

Question 4 — Will your app need to remember things or talk to other services?
Will your app need to:

1. Remember settings or store information (for example: a user's login for another service,
   preferences, or data not already in Stripe)
2. Talk to another service (for example: send emails, update a spreadsheet, call a third-party API)
3. No — it will only show Stripe data

Routing:

  • Option 1 or 2: Needs a back-end or the Secret Store API. Read backend.md.

    • If storing credentials or tokens, use the Secret Store API (plain-language: “Stripe has a built-in secure place to store passwords and tokens — you don’t need to build your own database for secrets”).

    • If running server-side logic, use a self-hosted back-end.

  • Option 3: Front-end-only. Only the SDK’s Stripe client and @stripe/ui-extension-sdk/ui needed. No back-end.

After discovery — summarize when useful

For a new app or a substantial architecture decision, summarize what you learned when it helps clarify the work:

Here's what I understood:

- You want to: [plain-language description of the goal]
- Your app will appear: [where, or "on a backend server"]
- It's for: [just you / other Stripe users]
- It needs to: [remember things / talk to [service] / just show Stripe data]

Ask for confirmation only if a material requirement or choice remains unresolved. Otherwise, proceed within the user’s request. Incorporate corrections without repeating questions or confirmations already answered.

Feature access

Access requirements vary by feature and extension point. Check current product documentation during discovery, and don’t infer a private-preview requirement for every extension interface.

Features to check:

FeatureTrigger phrases (user might say)What to tell the user
Custom objects“store custom data in Stripe”, “create my own data model”, “custom database in Stripe”, “custom fields on customers”, “structured data that isn’t in Stripe already”Check the custom objects documentation for current requirements, then explain any access prerequisite relevant to the user’s account.
Extension interfaces“change how Stripe calculates”, “custom billing logic”, “modify payment routing”, “override Stripe’s default behavior”, “custom tax calculation”Identify the exact extension point, then explain its current applicability and access requirements from its product documentation.

When to check:

  • If the user picks Option 5 in Question 1, follow the extension-interface routing above.

  • If the user’s description implies custom objects or extension interfaces, check the selected feature’s current requirements.

  • Ask the user to confirm access only when the selected feature requires it and the available information doesn’t establish access. Reuse access information already provided.

When access is required:

  • If the user confirms access, continue building with that feature.

  • If the user says they don’t have access, suggest alternatives:

    • Instead of custom objects, use the Secret Store API for key-value data, or store data in their own back-end.

    • Instead of extension interfaces, suggest a webhook-based approach that reacts to events rather than intercepting processing.

  • If the user is unsure, tell them: “You can check your access at the Stripe Apps page in your Dashboard, or ask your Stripe account representative. I can help you build with an alternative approach in the meantime.”

Plain-language glossary

Use these explanations when you need to introduce technical terms after routing:

TermPlain-language explanation
UI extensionThe part of your app that shows up inside the Stripe Dashboard
ViewportWhich specific Dashboard page your app appears on
Extension interfaceA hook that lets your app change how Stripe processes billing or payments
Platform keysHow your app accesses merchant data when they install it — no manual key-sharing needed
Connected accountA merchant who has installed your app
PermissionsWhat Stripe data your app is allowed to read or write; must be declared before use
Secret StoreStripe’s built-in way for your app to save sensitive information like passwords or tokens
stripe-app.yamlThe configuration file that tells Stripe what your app is called, what it needs access to, and where it appears
Custom objectsCustom data types you define and store inside Stripe; check the custom objects documentation for current availability and access requirements
SandboxAn isolated Stripe test environment for safe testing — useful for testing destructive operations or onboarding flows

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
Stripe
Publisher
Stripe (Official)
Source
stripe/ai · skills/stripe-apps · commit 38fa045
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Also distributed in
stripe/ai, stripe/ai, stripe/ai, stripe/ai, stripe/ai

AutoGineer is not affiliated with or endorsed by Stripe or Stripe.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download stripe-apps.zip