Quickstart

Every GRYPHEM PAY API key is a live key and every payment is real. You can sign up, set up your organization and submit your business verification right away. Live API keys, payment intents, checkout sessions and payouts are available once your account is activated: live payments are enabled once your account is verified and approved.

All examples use placeholders such as gp_live_YOUR_KEY and store_YOUR_STORE_ID — never paste real secrets into code.

Payments need an activated account

Steps 4 to 9 work only once your account is activated. Until then the API answers with feature_unavailable_error — for example live_keys_disabled when you try to create a live key. Every payment is real from the first one, so start with a small amount.

1. Create an account. Sign up at https://app.feitpay.com/auth/sign-up and verify your email, then create an organization and a store. The setup checklist tells you exactly what blocks the next step.

2. Submit your business verification. Under Organization → Compliance, complete the merchant application (KYB) and submit it. GRYPHEM operators review it manually; submitting is not an approval, and nothing is approved automatically.

3. Wait for activation. GRYPHEM activates your account for live payments once your verification is approved and the other requirements for live payments are met (see Regulatory status). The setup checklist marks its live-mode step as complete once your account is activated.

4. Create a live API key under Integrate → API keys with the payments:write and payments:read scopes. The secret (gp_live_…) is shown once LIVE · after account activation. Keep it on your server.

5. Register a webhook endpoint under Integrate → Webhooks, or with the API. Store the whsec_… signing secret; it is shown once. Register it after step 3: endpoints belong to one environment, and live events are delivered only to endpoints registered in live mode.

6. Create a payment intent.

   POST/v1/payment-intentslive · after account activation
   curl

   curl -X POST https://api.feitpay.com/v1/payment-intents \
     -H "Authorization: Bearer gp_live_YOUR_KEY" \
     -H "Idempotency-Key: order-123" \
     -H "Content-Type: application/json" \
     -d '{
       "store_id": "store_YOUR_STORE_ID",
       "amount": "59.90",
       "currency": "EUR",
       "merchant_order_id": "order-123",
       "return_url": "https://merchant.example/thank-you"
     }'

   TypeScript

   import { Gryphem } from '@gryphem-pay/sdk';
   
   const gp = new Gryphem({ apiKey: process.env.GRYPHEM_API_KEY!, baseUrl: 'https://api.feitpay.com' });
   
   const intent = await gp.paymentIntents.create(
     {
       store_id: 'store_YOUR_STORE_ID',
       amount: '59.90',
       currency: 'EUR',
       merchant_order_id: 'order-123',
       return_url: 'https://merchant.example/thank-you',
     },
     { idempotencyKey: 'order-123' },
   );
   console.log(intent.status, intent.checkout_url);

   Go

   client, err := gryphempay.New(os.Getenv("GRYPHEM_API_KEY"), gryphempay.WithBaseURL("https://api.feitpay.com"))
   if err != nil {
     log.Fatal(err)
   }
   intent, err := client.PaymentIntents.Create(ctx, &gryphempay.PaymentIntentCreateParams{
     StoreID:         "store_YOUR_STORE_ID",
     Amount:          "59.90",
     Currency:        "EUR",
     MerchantOrderID: "order-123",
     ReturnURL:       "https://merchant.example/thank-you",
     IdempotencyKey:  "order-123",
   })

   Python

   import os
   from gryphem_pay import Gryphem
   
   gp = Gryphem(api_key=os.environ["GRYPHEM_API_KEY"], base_url="https://api.feitpay.com")
   intent = gp.payment_intents.create(
       store_id="store_YOUR_STORE_ID",
       amount="59.90",
       currency="EUR",
       merchant_order_id="order-123",
       return_url="https://merchant.example/thank-you",
       idempotency_key="order-123",
   )
   print(intent["status"], intent["checkout_url"])

   The response is a payment_intent with status: "created", livemode: true, an expires_at, a hosted checkout_url on https://checkout.feitpay.com and a processor object (name: "bitcart", custodial: true). Retrying the same request with the same Idempotency-Key returns the same intent. Leave allowed_networks out: live payments offer every asset the platform accepts, and the field is refused with allowed_networks_unsupported.

7. The customer pays in the hosted checkout. Send the customer to checkout_url. The checkout opens an invoice in the platform’s Bitcart account and shows, for each accepted asset, an address, the exact amount calculated with Bitcart’s exchange rate and a QR code. The customer pays GRYPHEM PAY’s wallet; the amount is credited to your custodial balance once the payment is complete.

8. Watch the state machine. The intent moves awaiting_payment → detected → confirming → confirmed as Bitcart reports the invoice paid, confirmed and complete. The checkout, the dashboard and your webhook endpoint all see the same states.

9. Verify the webhook and fulfil. Your endpoint receives payment.confirmed. Verify the signature over the raw body (see Verify webhook signatures), dedupe on event_id, and fulfil only when data.fulfillable is true — re-checking with GET /v1/payment-intents/{id} before an irreversible action.

Withdraw your balance

Confirmed payments are credited to your custodial balance (GET /v1/balances). To withdraw, add an address under Finance → Payouts → Payout addresses (usable after a cooling-off period), request a payout and have a second member of your organization approve it (on by default). A GRYPHEM operator reviews every payout before the platform’s hot wallet sends it. Payouts are enabled separately from live payments; until they are, a payout request is refused with payouts_unavailable.

Run the examples

The repository ships runnable receivers that verify signatures and process each event once:

Example	Port	Run
examples/node-saas	4400	GRYPHEM_WEBHOOK_SECRET=whsec_… pnpm --filter @gryphem-pay/example-node-saas start
examples/go-webhook	4401	cd examples/go-webhook && GRYPHEM_WEBHOOK_SECRET=whsec_… go run .
examples/python-shop	4402	GRYPHEM_WEBHOOK_SECRET=whsec_… python examples/python-shop/shop.py

Next steps

• Understand every status in the state machine.
• See what the customer sees in the hosted checkout.
• Read the security model before you design your integration.
• Read the regulatory status to understand what account activation involves.