Quickstart

npm install @nekuda/react-nekuda-js

import React, { useState } from 'react';
import {
  NekudaWalletProvider,
  useNekudaWallet,
  NekudaPaymentForm
} from '@nekuda/react-nekuda-js'; // Assuming this is the correct import

function PaymentCollectionComponent() {
const [processing, setProcessing] = useState(false);
const [paymentSubmission, setPaymentSubmission] = useState(null);
const { elements } = useNekudaWallet(); // Hook from the wallet SDK
const userIdForNekuda = "user_frontend_example_123"; // Match this with backend user_id

const handleSubmit = async (event) => {
event.preventDefault();
if (!elements || processing) return;

    setProcessing(true);
    try {
      // The .submit() method on elements would typically handle talking to nekuda
      // to tokenize card details and might involve the userId.
      const result = await elements.submit(); // This is a conceptual example
      setPaymentSubmission(result); // result might contain a token or confirmation

      // Send the result (e.g., token, user_id) to your backend for processing with the Python nekuda SDK
      await fetch('/api/process-payment-with-nekuda', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          nekudaPaymentData: result, // Contains token/reference from frontend SDK
          userId: userIdForNekuda,
          amount: 49.99,
          currency: 'USD',
          productDescription: 'Frontend Purchase Example'
        })
      });
      alert('Payment data sent to backend!');
    } catch (err) {
      console.error('Frontend Payment SDK error:', err);
      alert('Payment collection failed.');
    }
    setProcessing(false);

};

return (

<NekudaPaymentForm>
  {" "}
  {/* This component would render the card input fields */}
  <button
    type="button"
    onClick={handleSubmit}
    disabled={!elements || processing}
  >
    {processing
      ? "Collecting Card Details..."
      : "Submit Card for Backend Processing"}
  </button>
</NekudaPaymentForm>
); }

uv pip install nekuda

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-payment-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 payment processor (Stripe, Braintree, etc.)
        # using card_details.card_number, card_details.card_expiry_date, etc.
        print(f"Simulating payment processing 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 processing 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.")