From 788e8a44c307006e015c18544158391133f89784 Mon Sep 17 00:00:00 2001 From: nihilg Date: Mon, 2 Feb 2026 13:48:19 +0000 Subject: [PATCH 1/2] initial commit - Checkout Kiro Power --- checkout/POWER.md | 164 ++++++++++++++ checkout/mcp.json | 8 + checkout/steering/advanced-usage.md | 312 +++++++++++++++++++++++++++ checkout/steering/getting-started.md | 191 ++++++++++++++++ 4 files changed, 675 insertions(+) create mode 100644 checkout/POWER.md create mode 100644 checkout/mcp.json create mode 100644 checkout/steering/advanced-usage.md create mode 100644 checkout/steering/getting-started.md diff --git a/checkout/POWER.md b/checkout/POWER.md new file mode 100644 index 0000000..c1c8c8b --- /dev/null +++ b/checkout/POWER.md @@ -0,0 +1,164 @@ +--- +name: "checkout-api-reference" +displayName: "Checkout.com Developer Experience MCP" +description: "Access Checkout.com's comprehensive API documentation with intelligent search and detailed operation information for payments, customers, disputes, and more." +version: "1.0.0" +author: "Checkout.com" +keywords: + - "checkout" + - "payments" + - "api" + - "documentation" + - "openapi" + - "fintech" + - "payment processing" + - "customers" + - "disputes" + - "issuing" + - "workflows" + - "identity verification" + - "mcp" + - "reference" +--- + +# Checkout.com Developer Experience MCP + +This power provides access to Checkout.com's comprehensive API documentation through a Model Context Protocol (MCP) server. It enables AI assistants to search, explore, and understand Checkout.com's payment processing APIs with over 189 operations covering payments, customers, disputes, issuing, platforms, workflows, and identity verification. + +## What This Power Does + +The Checkout.com Developer Experience MCP acts as an intelligent documentation assistant that can: + +- **Search API Operations**: Find relevant endpoints by keywords, functionality, or business domain +- **Explore API Structure**: Browse operations by tags and categories +- **Get Detailed Documentation**: Retrieve comprehensive information about specific endpoints including parameters, responses, and examples +- **Access Schema Definitions**: Get detailed schema information for request/response objects +- **Understand API Relationships**: Discover how different endpoints work together + +## Key Features + +### Comprehensive API Coverage +Access to all Checkout.com API operations including: +- **Payments**: Process payments, refunds, captures, and voids +- **Customers**: Manage customer profiles and payment instruments +- **Disputes**: Handle chargebacks and dispute management +- **Issuing**: Card issuing and management capabilities +- **Platforms**: Multi-entity and marketplace functionality +- **Workflows**: Automated business logic and event handling +- **Identity Verification**: KYC and identity checking services + +### Intelligent Search +- Keyword-based search across operation IDs, paths, summaries, and descriptions +- Tag-based filtering for specific API domains +- Fuzzy matching to find relevant operations even with partial information + +### Detailed Documentation Access +- Complete operation details including HTTP methods, paths, and parameters +- Request/response schema definitions with examples +- Error codes and handling information +- Authentication and authorization requirements + +## When to Use This Power + +This power is ideal for: + +- **API Integration Planning**: Understanding available endpoints and their capabilities +- **Development Support**: Getting detailed parameter and response information during coding +- **API Exploration**: Discovering new functionality and understanding API structure +- **Troubleshooting**: Finding relevant endpoints for specific use cases +- **Documentation Generation**: Creating comprehensive API documentation and guides + +## Available Tools + +### docssearch +Search through Checkout.com's API documentation for operations matching specific keywords. + +**Use Cases:** +- Find payment-related endpoints: "payment", "charge", "transaction" +- Discover customer management APIs: "customer", "profile", "account" +- Locate dispute handling operations: "dispute", "chargeback", "refund" + +### openapilistOperations +List and filter API operations with advanced filtering capabilities. + +**Use Cases:** +- Browse all operations in a specific domain (e.g., "Payments", "Customers") +- Find operations containing specific terms +- Get an overview of available functionality + +### openapigetOperation +Get comprehensive details about a specific API operation. + +**Use Cases:** +- Understand exact parameters required for an endpoint +- Get response schema and example data +- Learn about authentication requirements +- Find related operations and workflows + +### openapigetSchema +Retrieve detailed schema definitions for request/response objects. + +**Use Cases:** +- Understand data structures for API requests +- Validate request/response formats +- Generate client code with proper type definitions +- Create comprehensive API documentation + +### markdownsearch +Search through additional markdown documentation for contextual information. + +**Use Cases:** +- Find implementation guides and best practices +- Locate troubleshooting information +- Discover integration patterns and examples + +## Example Workflows + +### Finding Payment Processing Endpoints +1. Use `docssearch` with query "payment process" to find relevant operations +2. Use `openapigetOperation` to get detailed information about specific endpoints +3. Use `openapigetSchema` to understand request/response structures + +### Understanding Customer Management +1. Use `openapilistOperations` with tag "Customers" to see all customer-related endpoints +2. Explore specific operations like customer creation, updates, and retrieval +3. Get schema definitions for customer objects and related data structures + +### Exploring Dispute Handling +1. Search for dispute-related operations using `docssearch` +2. Get detailed operation information to understand the dispute lifecycle +3. Access schema definitions for dispute objects and status updates + +## Integration Benefits + +- **Faster Development**: Quickly find and understand the right APIs for your use case +- **Reduced Documentation Overhead**: Get answers without manually browsing extensive documentation +- **Better API Understanding**: Discover relationships between different endpoints and workflows +- **Improved Code Quality**: Access to complete schema definitions ensures proper implementation +- **Enhanced Troubleshooting**: Quickly find relevant endpoints and understand their behavior + +## Technical Architecture + +This power runs as an MCP server that: +- Loads and parses Checkout.com's OpenAPI specification +- Provides intelligent search and filtering capabilities +- Serves detailed documentation through standardized MCP tools +- Maintains up-to-date API information through bundled documentation + +The power is built with .NET 9.0 and follows clean architecture principles with comprehensive test coverage. + +--- + +## Privacy & Support + +### Privacy Policy +For information about how Checkout.com collects, stores, and processes user data, please review our [Privacy Policy](https://www.checkout.com/legal/privacy-policy). + +### Service Information +This power connects to Checkout.com's Developer Experience MCP service, which provides access to our API documentation and developer resources. The service is hosted and maintained by Checkout.com. + +### Support +For technical support, questions, or to report issues with this power, please contact our support team: +- [Checkout.com Support Center](https://support.checkout.com/hc/en-us) + +For API-related questions and developer resources, visit our [Developer Documentation](https://www.checkout.com/docs/). \ No newline at end of file diff --git a/checkout/mcp.json b/checkout/mcp.json new file mode 100644 index 0000000..9f855bc --- /dev/null +++ b/checkout/mcp.json @@ -0,0 +1,8 @@ +{ + "mcpServers": { + "checkout-dx": { + "url": "https://dx-mcp.checkout.com/rpc", + "disabled": false + } + } +} \ No newline at end of file diff --git a/checkout/steering/advanced-usage.md b/checkout/steering/advanced-usage.md new file mode 100644 index 0000000..687eaaf --- /dev/null +++ b/checkout/steering/advanced-usage.md @@ -0,0 +1,312 @@ +# Advanced Usage Guide - Checkout.com Developer Experience MCP + +This guide covers advanced techniques and patterns for maximizing the value of the Checkout.com Developer Experience MCP in complex integration scenarios. + +## Official Resources + +Before diving into advanced usage, familiarize yourself with Checkout.com's official resources: +- [Payment Authentication](https://www.checkout.com/docs/payments/authenticate-payments) +- [Marketplace Solutions](https://www.checkout.com/solutions/marketplaces) +- [Dispute Management](https://www.checkout.com/docs/disputes) +- [Workflow Automation](https://www.checkout.com/docs/workflows) +- [Security and Compliance](https://www.checkout.com/docs/payments/ensure-regulatory-compliance) + +## Advanced Search Techniques + +### Multi-Step Discovery Workflows + +For complex integrations, use a systematic approach to discover and understand related operations: + +1. **Domain Exploration** + ``` + List all operations with tag "Payments" + List all operations with tag "Workflows" + Search for operations containing "webhook" + ``` + +2. **Relationship Mapping** + ``` + Get details for createPayment operation + Get schema for PaymentRequest + Get schema for PaymentResponse + Search for operations containing "payment" and "capture" + ``` + +3. **Error Scenario Planning** + ``` + Search for operations containing "void" + Search for operations containing "refund" + Get details for disputePayment operation + ``` + +### Schema Deep Diving + +Understanding complex data structures requires systematic schema exploration: + +1. **Identify Core Schemas** + ``` + Get schema for PaymentRequest + Get schema for CustomerRequest + Get schema for WebhookEvent + ``` + +2. **Explore Nested Objects** + - Look for `$ref` references in schemas + - Follow object hierarchies to understand data relationships + - Map required vs optional fields across related schemas + +3. **Validate Data Flow** + - Trace how data flows from request to response + - Understand which response fields become input for subsequent operations + - Identify shared data structures across operations + +## Complex Integration Patterns + +### Multi-Step Payment Flows + +For sophisticated payment processing: + +1. **Authorization and Capture Pattern** + ``` + Get details for authorizePayment operation + Get details for capturePayment operation + Get schema for AuthorizationRequest + Get schema for CaptureRequest + ``` + +2. **Payment Instrument Management** + ``` + Search for operations containing "instrument" + Get details for createPaymentInstrument operation + Get details for updatePaymentInstrument operation + ``` + +3. **Recurring Payment Setup** + ``` + Search for operations containing "recurring" + Search for operations containing "subscription" + Get schema for RecurringPaymentRequest + ``` + +### Platform and Marketplace Integrations + +For multi-entity scenarios: + +1. **Sub-Entity Management** + ``` + List operations with tag "Platforms" + Get details for createSubEntity operation + Get schema for SubEntityRequest + ``` + +2. **Split Payment Scenarios** + ``` + Search for operations containing "split" + Search for operations containing "marketplace" + Get schema for SplitPaymentRequest + ``` + +3. **Onboarding Workflows** + ``` + Search for operations containing "onboard" + Get details for uploadDocument operation + Get schema for OnboardingRequest + ``` + +### Advanced Dispute Management + +For comprehensive dispute handling: + +1. **Dispute Lifecycle Management** + ``` + Get details for getDispute operation + Get details for acceptDispute operation + Get details for provideDisputeEvidence operation + Get schema for DisputeEvidence + ``` + +2. **Chargeback Prevention** + ``` + Search for operations containing "alert" + Search for operations containing "prevention" + Get details for getDisputeAlert operation + ``` + +## Workflow Automation Patterns + +### Event-Driven Architecture + +Understanding webhook and event patterns: + +1. **Event Type Discovery** + ``` + Search documentation for "webhook events" + Get schema for WebhookEvent + Search for operations containing "event" + ``` + +2. **Workflow Configuration** + ``` + List operations with tag "Workflows" + Get details for createWorkflow operation + Get schema for WorkflowRequest + ``` + +3. **Event Processing Patterns** + ``` + Search documentation for "event handling" + Search for operations containing "retry" + Get details for getWorkflowExecution operation + ``` + +### Identity Verification Workflows + +For KYC and compliance: + +1. **Verification Process Discovery** + ``` + List operations with tag "Identity Verification" + Get details for createIdentityVerification operation + Get schema for IdentityVerificationRequest + ``` + +2. **Document Management** + ``` + Search for operations containing "document" + Get details for uploadDocument operation + Get schema for DocumentRequest + ``` + +## Performance and Optimization + +### Efficient API Usage Patterns + +1. **Batch Operations Discovery** + ``` + Search for operations containing "batch" + Search for operations containing "bulk" + Get details for batchPayments operation + ``` + +2. **Pagination Understanding** + ``` + Search documentation for "pagination" + Get schema for PaginatedResponse + Look for limit/offset parameters in list operations + ``` + +3. **Rate Limit Management** + ``` + Search documentation for "rate limits" + Search documentation for "throttling" + Look for rate limit headers in operation responses + ``` + +### Caching and Data Management + +1. **Cacheable Resource Identification** + - Identify GET operations that return stable data + - Look for ETags and cache headers in responses + - Understand data freshness requirements + +2. **Idempotency Patterns** + ``` + Search documentation for "idempotency" + Look for idempotency key parameters + Understand retry-safe operations + ``` + +## Security and Compliance + +### Authentication Deep Dive + +1. **Auth Method Discovery** + ``` + Search documentation for "authentication" + Search documentation for "authorization" + Look for security requirements in operation details + ``` + +2. **Token Management** + ``` + Search for operations containing "token" + Get details for createToken operation + Get schema for TokenRequest + ``` + +### PCI and Compliance + +1. **Secure Data Handling** + ``` + Search documentation for "PCI compliance" + Search documentation for "sensitive data" + Identify operations that handle card data + ``` + +2. **Audit and Logging** + ``` + Search for operations containing "audit" + Search for operations containing "log" + Get details for getAuditLog operation + ``` + +## Troubleshooting Advanced Scenarios + +### Error Analysis Patterns + +1. **Error Code Mapping** + ``` + Search documentation for "error codes" + Look for error responses in operation details + Get schema for ErrorResponse + ``` + +2. **Diagnostic Operations** + ``` + Search for operations containing "status" + Search for operations containing "health" + Get details for getSystemStatus operation + ``` + +### Integration Testing + +1. **Test Environment Setup** + ``` + Search documentation for "sandbox" + Search documentation for "testing" + Look for test-specific operations and endpoints + ``` + +2. **Mock Data Discovery** + ``` + Search documentation for "test data" + Search documentation for "examples" + Look for example values in schema definitions + ``` + +## Best Practices for Power Usage + +### Systematic Exploration +- Always start with broad searches and narrow down +- Use schema exploration to understand data relationships +- Map complete workflows before implementation + +### Documentation Strategy +- Save important operation IDs and schema names for quick reference +- Document discovered patterns and relationships +- Create integration checklists based on discovered operations + +### Continuous Learning +- Regularly explore new API areas as your integration grows +- Stay updated with new operations and schema changes +- Use the power to understand deprecation notices and migration paths + +This advanced usage guide helps you leverage the full potential of the Checkout.com Developer Experience MCP for sophisticated payment processing integrations. + +## Additional Resources + +For comprehensive implementation guidance, consult these official resources: +- [Checkout.com Developer Portal](https://www.checkout.com/docs/) +- [API Status and Updates](https://status.checkout.com/) +- [Testing and Test Cards](https://www.checkout.com/docs/testing/test-cards) +- [API Authentication](https://www.checkout.com/docs/resources/api-authentication/) \ No newline at end of file diff --git a/checkout/steering/getting-started.md b/checkout/steering/getting-started.md new file mode 100644 index 0000000..7136bfe --- /dev/null +++ b/checkout/steering/getting-started.md @@ -0,0 +1,191 @@ +# Getting Started with Checkout.com Developer Experience MCP + +This guide will help you quickly start using the Checkout.com Developer Experience MCP to explore and understand Checkout.com's payment processing APIs. + +## Official Documentation + +For comprehensive information about Checkout.com's APIs, refer to the official documentation: +- [Checkout.com API Documentation](https://www.checkout.com/docs/) +- [API Reference](https://api-reference.checkout.com/) +- [Get Started Guide](https://www.checkout.com/docs/get-started) +- [SDKs](https://www.checkout.com/docs/integrate/sdks) + +## Quick Start + +Once the power is activated, you have access to five main tools for exploring Checkout.com's API documentation: + +### 1. Search for API Operations (`docssearch`) + +The fastest way to find relevant endpoints is through keyword search: + +``` +Search for payment processing endpoints +``` + +This will use the `docssearch` tool to find operations related to payments. You can search for: +- **Business functions**: "payment", "refund", "customer", "dispute" +- **Technical terms**: "webhook", "authentication", "token" +- **Specific operations**: "create", "update", "delete", "list" + +### 2. Browse Operations by Category (`openapilistOperations`) + +To explore operations in a specific domain: + +``` +List all customer-related operations +``` + +This helps you understand the full scope of functionality available in each API domain. + +### 3. Get Detailed Operation Information (`openapigetOperation`) + +Once you find an interesting operation, get comprehensive details: + +``` +Get details for the createPayment operation +``` + +This provides complete information including: +- HTTP method and path +- Required and optional parameters +- Request/response schemas +- Authentication requirements +- Example requests and responses + +### 4. Understand Data Structures (`openapigetSchema`) + +To understand the data structures used in requests and responses: + +``` +Get the schema definition for PaymentRequest +``` + +This is essential for: +- Understanding required fields +- Validating data formats +- Generating client code +- Creating proper API requests + +### 5. Search Documentation (`markdownsearch`) + +For additional context and implementation guidance: + +``` +Search for webhook implementation examples +``` + +## Common Use Cases + +### Planning a Payment Integration + +1. **Discover Payment Operations** + ``` + Search for payment processing operations + ``` + +2. **Understand Payment Flow** + ``` + Get details for createPayment operation + Get schema for PaymentRequest + ``` + +3. **Explore Related Operations** + ``` + List operations containing "payment" + Get details for capturePayment operation + Get details for refundPayment operation + ``` + +### Setting Up Customer Management + +1. **Find Customer Operations** + ``` + List operations with tag "Customers" + ``` + +2. **Understand Customer Creation** + ``` + Get details for createCustomer operation + Get schema for CustomerRequest + ``` + +3. **Explore Customer Lifecycle** + ``` + Get details for updateCustomer operation + Get details for deleteCustomer operation + ``` + +### Handling Disputes and Chargebacks + +1. **Discover Dispute Operations** + ``` + Search for dispute and chargeback operations + ``` + +2. **Understand Dispute Process** + ``` + Get details for getDispute operation + Get schema for DisputeResponse + ``` + +### Implementing Webhooks + +1. **Find Webhook Information** + ``` + Search documentation for webhook setup + Search for webhook-related operations + ``` + +2. **Understand Event Types** + ``` + Get schema for WebhookEvent + Search documentation for event types + ``` + +## Tips for Effective Usage + +### Search Strategy +- Start with broad terms like "payment" or "customer" +- Use specific operation names when you know them +- Try different variations: "create", "add", "new" might find the same operations + +### Understanding Relationships +- Operations often work together in workflows +- Use schema definitions to understand data flow between operations +- Look for common parameters that link operations + +### Schema Exploration +- Always check schema definitions for complex operations +- Pay attention to required vs optional fields +- Look for nested objects and their schemas + +### Documentation Context +- Use markdown search for implementation guidance +- Look for best practices and common patterns +- Find troubleshooting information for complex scenarios + +## Next Steps + +After getting familiar with the basic tools: + +1. **Explore Specific Domains**: Focus on the API areas most relevant to your use case +2. **Understand Authentication**: Learn about API keys, OAuth, and other auth methods +3. **Review Error Handling**: Understand error codes and proper error handling +4. **Check Rate Limits**: Learn about API usage limits and best practices +5. **Explore Advanced Features**: Discover webhooks, workflows, and platform features + +## Getting Help + +If you need assistance: +- Use broad search terms to discover relevant operations +- Check schema definitions for data structure questions +- Search documentation for implementation guidance +- Explore related operations to understand complete workflows + +The power provides access to comprehensive, up-to-date API documentation, making it easy to find exactly what you need for your Checkout.com integration. + +For additional resources and detailed implementation guides, visit: +- [Checkout.com Developer Portal](https://www.checkout.com/docs/) +- [API Reference](https://api-reference.checkout.com/) +- [Webhook Management](https://www.checkout.com/docs/developer-resources/webhooks/manage-webhooks/) +- [Authentication Guide](https://www.checkout.com/docs/resources/api-authentication/) \ No newline at end of file From c9c4ec95a610c2ff59af1f0aa9bf369cf0643354 Mon Sep 17 00:00:00 2001 From: nihilg Date: Tue, 3 Feb 2026 14:43:26 +0000 Subject: [PATCH 2/2] updated displayName --- checkout/POWER.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/checkout/POWER.md b/checkout/POWER.md index c1c8c8b..a302003 100644 --- a/checkout/POWER.md +++ b/checkout/POWER.md @@ -1,6 +1,6 @@ --- name: "checkout-api-reference" -displayName: "Checkout.com Developer Experience MCP" +displayName: "Checkout.com Global Payments" description: "Access Checkout.com's comprehensive API documentation with intelligent search and detailed operation information for payments, customers, disputes, and more." version: "1.0.0" author: "Checkout.com"