Quickstart

uv pip install @nekuda/nekuda-js

from fastapi import FastAPI, HTTPException
from nekuda import NekudaClient, MandateData, NekudaError # Python SDK
import os
from pydantic import BaseModel

app = FastAPI()

# Initialize the nekuda Python client (recommended: from environment)

# Ensure NEKUDA_SECRET_KEY and optionally NEKUDA_BASE_URL are set.

# NEKUDA_BASE_URL defaults to https://api.nekuda.ai

nekuda_client = NekudaClient.from_env()

class PaymentProcessingRequest(BaseModel):
nekudaPaymentData: dict # Data from frontend SDK (e.g., a token)
userId: str
amount: float
currency: str
productDescription: str

@app.post("/api/process-information-with-nekuda")
async def process_payment_with_nekuda(request_data: PaymentProcessingRequest):
user_id = request_data.userId
user_context = nekuda_client.user(user_id)

    try:
        # Step 1: Create a Mandate (user's intent to purchase)
        # This uses the user_id provided from the frontend, which should match the one
        # used during the frontend SDK initialization for this user.
        print(f"Creating mandate for user: {user_id}")
        mandate_details = MandateData(
            product=request_data.productDescription,
            price=request_data.amount,
            currency=request_data.currency,
            merchant="Your Awesome Store"
        )
        mandate_response = user_context.create_mandate(mandate_details)
        print(f"Mandate {mandate_response.mandate_id} created for user {user_id}.")

        # Step 2: Request a card reveal token using the mandate_id.
        # The nekudaPaymentData from frontend might be used here if it contains a reference
        # that nekuda backend needs, or it might have already been used by the frontend SDK
        # to store the card against the user_id.
        # For this example, we assume card details were collected by frontend SDK and associated
        # with the user_id, and now we are proceeding with that context.
        print(f"Requesting reveal token for mandate: {mandate_response.mandate_id}")
        reveal_token_response = user_context.request_card_reveal_token(
            mandate_id=mandate_response.mandate_id
        )
        print(f"Reveal token obtained: {reveal_token_response.reveal_token[:10]}...")

        # Step 3: Reveal actual card details using the token.
        print("Revealing card details...")
        card_details = user_context.reveal_card_details(
            reveal_token=reveal_token_response.reveal_token
        )
        print(f"Card details revealed: **** **** **** {card_details.card_number[-4:]}")

        # Step 4: Process payment with the actual card details.
        # This is where you'd integrate with your information collection processor (Stripe, Braintree, etc.)
        # using card_details.card_number, card_details.card_expiry_date, etc.
        print(f"Simulating information handling for {card_details.cardholder_name}...")
        # payment_processor.charge(card_details, request_data.amount, request_data.currency)

        return {
            "success": True,
            "transaction_id": f"nekuda_txn_{mandate_response.mandate_id}",
            "message": "Payment processed successfully via nekuda flow."
        }

    except NekudaError as e:
        print(f"nekuda SDK Error for user {user_id}: {e}")
        # Provide specific error messages based on e.code or e.status_code
        raise HTTPException(status_code=400, detail=f"Payment handling failed: {str(e)}")
    except Exception as e:
        print(f"Generic Error for user {user_id}: {e}")
        raise HTTPException(status_code=500, detail="An unexpected error occurred.")