Skip to content
Skills Library
Finance & accounting · Tool integration

payment

/payment

Use this skill whenever the user wants to integrate, implement, or test a payment API from an African provider — including Paycard, LengoPay, Wave, Djomy, Bictorys, or any provider in the Afro.tools registry. Activate even if the user only says "add payment", "connect to Paycard", or "implement a checkout flow" — always fetch the exact spec before writing any code.

Repository
afrotools ↗
Licence
Apache-2.0
Last repository change
28.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 28.10.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Use this skill whenever the user wants to integrate, implement, or test a payment API from an African provider — including Paycard, LengoPay, Wave, Djomy, Bictorys, or any provider in the Afro.tools registry. Activate even if the user only says "add payment", "connect to Paycard", or "implement a checkout flow" — always fetch the exact spec before writing any code.

Triggers from the description

add paymentconnect to Paycardimplement a checkout flow
Original author description

Use this skill whenever the user wants to integrate, implement, or test a payment API from an African provider — including Paycard, LengoPay, Wave, Djomy, Bictorys, or any provider in the Afro.tools registry. Activate even if the user only says "add payment", "connect to Paycard", or "implement a checkout flow" — always fetch the exact spec before writing any code.

How it works

  1. Workflow
  2. After the integration
  3. Important
Original SKILL.md headings · 86 lines, 713 words
SKILL.md preview
---
name: payment
description: >
  Use this skill whenever the user wants to integrate, implement, or test a
  payment API from an African provider — including Paycard, LengoPay, Wave,
  Djomy, Bictorys, or any provider in the Afro.tools registry. Activate even
  if the user only says "add payment", "connect to Paycard", or "implement a
  checkout flow" — always fetch the exact spec before writing any code.
---

# Afro.tools — Payment skill

When this skill activates, use the `afrotools` MCP server to retrieve the spec
for the target provider and capability before writing any implementation code.

## Workflow

1. Identify the provider slug and capability from the user's request.
   - Discover what's actually available with `afrotools.list_providers()`: it lists every
     provider with its countries and the exact names of its capabilities. To narrow down, use
     `afrotools.search_specs({ category: "payment", country_code: "<ISO alpha-2, uppercase>" })`
     (or `provider`) — keep a filter on: a whole-category search can be too large to read.
     Never assume a provider has (or lacks) a spec from memory or from a previous session —
     the registry grows independently of this skill.
   - Capability names are each provider's own: pick them from the provider's `capabilities`
     list, never guess one. A `get_spec` "not found" means the name is wrong, not that the
     provider is missing — check the list again before concluding anything.
   - Only if the provider is absent from `list_providers()`, or none of its capabilities
     covers what the user needs:
     1. Call `afrotools.request_spec({ provider: "<slug>", capability: "<capability>" })`
        so the maintainers are notified of the demand.
     2. Tell the user: "The spec for {provider} isn't available yet — I've logged
        your request. You can track available specs with `/afrotools:list`."
     3. Stop — don't attempt to implement without a spec.

2. Call the MCP tool to fetch the spec:
   ```
   afrotools.get_spec({ provider: "<slug>", capability: "<capability>" })
   ```
   If the user is building a full payment flow, fetch upfront the provider's capability for
   each step, choosing the names from its `capabilities` list (they differ per provider):
   - initiating the payment (and getting the payment URL, if it is a hosted checkout)
   - confirming the payment status server-side
   - the payment webhook, for async callbacks

3. Read the spec carefully before writing code:
   - `auth` — how to authenticate. When present, `auth.credentials` lists every secret to ask
     the user for (as env vars), `auth.signing` how to compute `{signature}`,
     `auth.token_exchange` how to get `{access_token}`, and `auth.apply` what each request
     sends — follow them exactly; older specs describe these steps in `gotchas`
   - `endpoint` — method and URL. `environments` (when present) gives each environment's base
     URL; one that is missing is not documented — ask the user for it, never guess
   - `webhook.signature` (webhook capabilities) — how to verify the provider's signature
     before trusting the payload
   - `input_schema` — required and optional fields
   - `response_schema` — what a success response looks like
   - `error_schema` — how errors are returned
   - `gotchas` — **always surface these to the user**
   - `status` / `verification` — `ready` means written from the provider's docs, not yet
     tested against the API; a `verified` spec says where it was tested
     (`verification.environment`: `sandbox` or `production`). Tell the user which.
   - `open_questions` — if present, what the docs do not answer: tell the user before relying on it

4. Implement using the `canonical_example.ts` pattern:
   - Native fetch only — no axios, no node-fetch
   - Credentials from `process.env`
   - Always verify payment status server-side before fulfilling an order

## After the integration

Reports are how specs get verified and fixed. The user usually tests later, so do not wait for
them to say it worked:

- **The spec is not `verified`** — when you finish the integration, tell the user once that this
  spec has never been tested against the provider's API, and that when they have tested it
  (sandbox or production) you can prepare a report: a working report makes it `verified`,
  credited to them.
- **The spec is `verified`** — offer a report only if something failed.
- **The spec is wrong** (the API does not match it) — offer a report right away.

When they come back with a result:

```
afrotools.report_integration({ provider: "<slug>", capabilities: [{ capability: "<capability>", result: "worked" }, …], summary: "<one line>", details: "<what was called, what came back, what differed>" })
```

List every capability the flow used (e.g. payment init, status, webhook), each with its own
result — one report per provider. Give the user the returned link: they choose the environment and
the outcome, check the text, and submit it themselves. Never put API keys, tokens, phone numbers
or personal data in `details`.

## Important

Never skip the gotchas. They represent real integration failures.

Versions

The database has no other skills named payment.

Database snapshot: 13.11.2026 · package version 8528e79e280c (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100debug
    Use this skill ONLY when the user has a failing integration that is specifically based on an Afro.tools spec — the user is integrating a provider whose spec exists in the Afro.tools registry (Paycard, LengoPay, Djomy, Wave, NimbaSMS, etc.) and encounters wrong status codes, auth…
  • 100identity
    Use this skill whenever the user wants to integrate, implement, or test an identity verification (KYC) API from an African provider — ID number checks, ID document verification with a selfie, AML / sanctions / PEP screening, or hosted verification links — including Smile ID or…
  • 90TossPayments Integration Guide
    TossPayments payment integration documentation access via MCP. Use when integrating TossPayments payment widget, checkout flow, payment approval API, or when user mentions 토스페이먼츠, 결제, 결제위젯, 결제 승인, payment widget, TossPayments SDK, payment approval.
  • 100payment-gateway-integration
    Integrate a payment provider with idempotent charges, signature-checked webhooks, and an explicit map from provider states to order states. Use when adding or changing checkout payment, capture, refund, or payment notification handling.
  • 90ecommerce-payment-processing
    Use when the user asks about payment processing, payment gateway integration, Stripe, PayPal, subscription billing, PCI DSS compliance, payment orchestration, or recurring payments. Do NOT use for: general e-commerce checkout flow (ecommerce-checkout-cart), or in-app purchases…
  • 100payment-integration
    Integrate Stripe, PayPal, and payment processors. Handles checkout flows, subscriptions, webhooks, and PCI compliance. Use when implementing payments, billing, or subscription features.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.