SDKs

Official MPPFi SDKs for TypeScript, Python, Rust, and Go - enabling seamless integration with the first neobank infrastructure for AI agents built on Solana blockchain with Machine Payments Protocol.

Installation

TypeScript/Node.js

npm install @mppfi/node
# or
yarn add @mppfi/node
# or
pnpm add @mppfi/node

Requirements: Node.js 18+ or modern browsers (Edge Runtime compatible)

Python

pip install mppfi

Requirements: Python 3.9+

Rust

cargo add mppfi

Requirements: Rust 1.70+

Go

go get github.com/mppfi/mppfi-go

Requirements: Go 1.21+

---

TypeScript SDK

Initialization

import { MPPFi } from '@mppfi/node';

const mppfi = new MPPFi({
  apiKey: process.env.MPPFI_API_KEY,
  environment: 'production', // or 'sandbox'
  timeout: 30000, // optional, in milliseconds
  maxRetries: 3, // optional, default: 3
  solanaRpc: 'https://api.mainnet-beta.solana.com' // optional
});

Agent Accounts

// Create agent account
const agent = await mppfi.agents.create({
  name: 'Order Processing Agent',
  description: 'Handles automated purchase orders',
  initialBalance: '1000.00',
  policies: [
    {
      type: 'amount_limit',
      maxTransaction: '500.00',
      maxDaily: '5000.00'
    }
  ],
  metadata: {
    environment: 'production',
    version: '2.1.0'
  }
});

console.log(`Agent created with Solana address: ${agent.solanaAddress}`);

// List agents
const agents = await mppfi.agents.list({
  limit: 20,
  status: 'active'
});

// Retrieve agent
const agent = await mppfi.agents.retrieve('agent_7x8y9z');

// Update agent
await mppfi.agents.update('agent_7x8y9z', {
  name: 'Updated Agent Name',
  metadata: { version: '2.2.0' }
});

// Get balance
const balance = await mppfi.agents.getBalance('agent_7x8y9z');
console.log(`Available: ${balance.available} ${balance.currency}`);
console.log(`Solana address: ${balance.solanaAddress}`);

// Suspend agent
await mppfi.agents.suspend('agent_7x8y9z');

// Reactivate agent
await mppfi.agents.reactivate('agent_7x8y9z');

// Close agent
await mppfi.agents.close('agent_7x8y9z', {
  withdrawalAddress: '5xPq7...3mKt9'
});

Payments (Machine Payments Protocol)

// Create MPP payment
const payment = await mppfi.payments.create({
  agentId: 'agent_7x8y9z',
  amount: '150.50',
  currency: 'USDC',
  merchantId: 'merchant_abc123',
  description: 'API subscription - March 2026',
  mppProtocol: {
    version: '1.0',
    serviceCode: 'api_access',
    authorizationMethod: 'cryptographic_signature'
  },
  metadata: {
    orderId: 'ORD-2026-03-001'
  },
  idempotencyKey: 'payment_20260330_001'
});

// Access blockchain details
console.log(`Transaction signature: ${payment.blockchain.transactionSignature}`);
console.log(`Block explorer: ${payment.blockchain.explorerUrl}`);
console.log(`Confirmation status: ${payment.blockchain.confirmationStatus}`);

// List payments
const payments = await mppfi.payments.list({
  agentId: 'agent_7x8y9z',
  status: 'completed',
  createdAfter: '2026-03-01T00:00:00Z',
  limit: 50
});

// Retrieve payment
const payment = await mppfi.payments.retrieve('pay_xyz123');

// Cancel pending payment
await mppfi.payments.cancel('pay_xyz123');

Direct Transfers

// Create direct USDC transfer
const transfer = await mppfi.transfers.create({
  agentId: 'agent_7x8y9z',
  recipientAddress: '8yLp2...5nKq7',
  amount: '250.00',
  currency: 'USDC',
  description: 'Payment to supplier',
  metadata: {
    invoiceId: 'INV-2026-150'
  }
});

console.log(`Transfer signature: ${transfer.blockchain.transactionSignature}`);

// List transfers
const transfers = await mppfi.transfers.list({
  agentId: 'agent_7x8y9z',
  limit: 20
});

Policies (On-Chain Enforcement)

// Create policy
const policy = await mppfi.policies.create({
  agentId: 'agent_7x8y9z',
  name: 'Daily Spending Limit',
  description: 'Restrict agent to $5,000 daily spending',
  rules: [
    {
      type: 'amount_limit',
      maxTransaction: '500.00',
      maxDaily: '5000.00'
    },
    {
      type: 'merchant_allowlist',
      allowedMerchants: [
        'merchant_abc123',
        'merchant_def456'
      ]
    },
    {
      type: 'time_restriction',
      allowedHours: {
        start: '09:00',
        end: '17:00',
        timezone: 'UTC'
      },
      allowedDays: ['monday', 'tuesday', 'wednesday', 'thursday', 'friday']
    }
  ],
  enforcement: 'on_chain',
  priority: 1
});

// Policy is deployed to Solana
console.log(`Policy deployed at: ${policy.blockchain.programAddress}`);
console.log(`Deployment signature: ${policy.blockchain.deploymentSignature}`);

// List policies
const policies = await mppfi.policies.list({
  agentId: 'agent_7x8y9z',
  status: 'active'
});

// Update policy (redeploys to blockchain)
await mppfi.policies.update('policy_abc123', {
  rules: [
    {
      type: 'amount_limit',
      maxTransaction: '1000.00',
      maxDaily: '10000.00'
    }
  ]
});

// Disable policy
await mppfi.policies.disable('policy_abc123');

// Enable policy
await mppfi.policies.enable('policy_abc123');

Merchants

// List MPP-compatible merchants
const merchants = await mppfi.merchants.list({
  category: 'ai_services',
  mppVersion: '1.0',
  limit: 50
});

for (const merchant of merchants.data) {
  console.log(`${merchant.name} - ${merchant.solanaAddress}`);
}

// Retrieve merchant details
const merchant = await mppfi.merchants.retrieve('merchant_abc123');
console.log(`Service codes: ${merchant.serviceCodes.join(', ')}`);
console.log(`Pricing: ${JSON.stringify(merchant.pricing, null, 2)}`);

Analytics

// Get agent analytics
const analytics = await mppfi.agents.getAnalytics('agent_7x8y9z', {
  startDate: '2026-03-01T00:00:00Z',
  endDate: '2026-03-31T23:59:59Z'
});

console.log(`Total transactions: ${analytics.metrics.totalTransactions}`);
console.log(`Total volume: $${analytics.metrics.totalVolume}`);
console.log(`Success rate: ${(analytics.metrics.successRate * 100).toFixed(2)}%`);

// By merchant
analytics.byMerchant.forEach(m => {
  console.log(`${m.merchantName}: ${m.transactionCount} txns, $${m.totalVolume}`);
});

// Get payment analytics
const paymentAnalytics = await mppfi.analytics.getPayments({
  startDate: '2026-03-01T00:00:00Z',
  endDate: '2026-03-31T23:59:59Z',
  groupBy: 'day'
});

Webhooks

// Create webhook
const webhook = await mppfi.webhooks.create({
  url: 'https://example.com/webhooks/mppfi',
  description: 'Production webhook endpoint',
  events: [
    'payment.completed',
    'payment.failed',
    'agent.balance.low',
    'policy.violated'
  ],
  enabled: true
});

// Save the signing secret securely
console.log(`Signing secret: ${webhook.signingSecret}`);

// Verify webhook signature (in your webhook handler)
import { verifyWebhookSignature } from '@mppfi/node';

export async function POST(request: Request) {
  const body = await request.text();
  const signature = request.headers.get('X-MPPFi-Signature');

  try {
    const event = verifyWebhookSignature(
      body,
      signature,
      process.env.WEBHOOK_SECRET
    );

    // Handle event
    switch (event.type) {
      case 'payment.completed':
        console.log(`Payment completed: ${event.data.payment.id}`);
        break;
      case 'policy.violated':
        console.log(`Policy violation: ${event.data.policy.id}`);
        break;
    }

    return Response.json({ received: true });
  } catch (error) {
    return Response.json({ error: 'Invalid signature' }, { status: 401 });
  }
}

// List webhooks
const webhooks = await mppfi.webhooks.list();

// Update webhook
await mppfi.webhooks.update('webhook_jkl012', {
  enabled: false
});

// Delete webhook
await mppfi.webhooks.delete('webhook_jkl012');

Error Handling

import {
  MPPFiError,
  InsufficientBalanceError,
  PolicyViolationError,
  AuthenticationError,
  RateLimitError,
  NotFoundError
} from '@mppfi/node';

try {
  const payment = await mppfi.payments.create({
    agentId: 'agent_7x8y9z',
    amount: '10000.00',
    merchantId: 'merchant_abc123'
  });
} catch (error) {
  if (error instanceof InsufficientBalanceError) {
    console.error('Agent has insufficient balance');
  } else if (error instanceof PolicyViolationError) {
    console.error(`Policy violation: ${error.policyId}`);
    console.error(`Reason: ${error.reason}`);
  } else if (error instanceof AuthenticationError) {
    console.error('Invalid API key');
  } else if (error instanceof RateLimitError) {
    console.error(`Rate limit exceeded. Retry after ${error.retryAfter}s`);
  } else if (error instanceof NotFoundError) {
    console.error('Resource not found');
  } else if (error instanceof MPPFiError) {
    console.error(`MPPFi error: ${error.message}`);
    console.error(`Request ID: ${error.requestId}`);
  } else {
    console.error('Unexpected error:', error);
  }
}

TypeScript Types

Full TypeScript support with auto-completion:

import type {
  Agent,
  Payment,
  Transfer,
  Policy,
  Merchant,
  Webhook,
  Balance
} from '@mppfi/node';

const agent: Agent = await mppfi.agents.create({
  name: 'Trading Agent',
  initialBalance: '5000.00'
});

const payment: Payment = await mppfi.payments.create({
  agentId: agent.id,
  amount: '100.00',
  merchantId: 'merchant_abc123'
});

---

Python SDK

Initialization

from mppfi import MPPFi
import os

mppfi = MPPFi(
    api_key=os.environ.get('MPPFI_API_KEY'),
    environment='production',
    timeout=30,
    max_retries=3,
    solana_rpc='https://api.mainnet-beta.solana.com'
)

Agent Accounts

# Create agent account
agent = mppfi.agents.create(
    name='Order Processing Agent',
    description='Handles automated purchase orders',
    initial_balance='1000.00',
    policies=[
        {
            'type': 'amount_limit',
            'max_transaction': '500.00',
            'max_daily': '5000.00'
        }
    ],
    metadata={
        'environment': 'production',
        'version': '2.1.0'
    }
)

print(f"Agent created with Solana address: {agent.solana_address}")

# List agents
agents = mppfi.agents.list(limit=20, status='active')

# Retrieve agent
agent = mppfi.agents.retrieve('agent_7x8y9z')

# Update agent
mppfi.agents.update('agent_7x8y9z',
    name='Updated Agent Name',
    metadata={'version': '2.2.0'}
)

# Get balance
balance = mppfi.agents.get_balance('agent_7x8y9z')
print(f"Available: {balance.available} {balance.currency}")
print(f"Solana address: {balance.solana_address}")

# Suspend agent
mppfi.agents.suspend('agent_7x8y9z')

# Reactivate agent
mppfi.agents.reactivate('agent_7x8y9z')

# Close agent
mppfi.agents.close('agent_7x8y9z',
    withdrawal_address='5xPq7...3mKt9'
)

Payments (Machine Payments Protocol)

# Create MPP payment
payment = mppfi.payments.create(
    agent_id='agent_7x8y9z',
    amount='150.50',
    currency='USDC',
    merchant_id='merchant_abc123',
    description='API subscription - March 2026',
    mpp_protocol={
        'version': '1.0',
        'service_code': 'api_access',
        'authorization_method': 'cryptographic_signature'
    },
    metadata={
        'order_id': 'ORD-2026-03-001'
    },
    idempotency_key='payment_20260330_001'
)

# Access blockchain details
print(f"Transaction signature: {payment.blockchain.transaction_signature}")
print(f"Block explorer: {payment.blockchain.explorer_url}")
print(f"Confirmation status: {payment.blockchain.confirmation_status}")

# List payments
payments = mppfi.payments.list(
    agent_id='agent_7x8y9z',
    status='completed',
    created_after='2026-03-01T00:00:00Z',
    limit=50
)

for payment in payments:
    print(f"{payment.merchant_name}: ${payment.amount}")

# Retrieve payment
payment = mppfi.payments.retrieve('pay_xyz123')

# Cancel pending payment
mppfi.payments.cancel('pay_xyz123')

Direct Transfers

# Create direct USDC transfer
transfer = mppfi.transfers.create(
    agent_id='agent_7x8y9z',
    recipient_address='8yLp2...5nKq7',
    amount='250.00',
    currency='USDC',
    description='Payment to supplier',
    metadata={
        'invoice_id': 'INV-2026-150'
    }
)

print(f"Transfer signature: {transfer.blockchain.transaction_signature}")

# List transfers
transfers = mppfi.transfers.list(
    agent_id='agent_7x8y9z',
    limit=20
)

Policies (On-Chain Enforcement)

# Create policy
policy = mppfi.policies.create(
    agent_id='agent_7x8y9z',
    name='Daily Spending Limit',
    description='Restrict agent to $5,000 daily spending',
    rules=[
        {
            'type': 'amount_limit',
            'max_transaction': '500.00',
            'max_daily': '5000.00'
        },
        {
            'type': 'merchant_allowlist',
            'allowed_merchants': [
                'merchant_abc123',
                'merchant_def456'
            ]
        },
        {
            'type': 'time_restriction',
            'allowed_hours': {
                'start': '09:00',
                'end': '17:00',
                'timezone': 'UTC'
            },
            'allowed_days': ['monday', 'tuesday', 'wednesday', 'thursday', 'friday']
        }
    ],
    enforcement='on_chain',
    priority=1
)

# Policy is deployed to Solana
print(f"Policy deployed at: {policy.blockchain.program_address}")
print(f"Deployment signature: {policy.blockchain.deployment_signature}")

# List policies
policies = mppfi.policies.list(
    agent_id='agent_7x8y9z',
    status='active'
)

# Update policy (redeploys to blockchain)
mppfi.policies.update('policy_abc123',
    rules=[
        {
            'type': 'amount_limit',
            'max_transaction': '1000.00',
            'max_daily': '10000.00'
        }
    ]
)

# Disable policy
mppfi.policies.disable('policy_abc123')

# Enable policy
mppfi.policies.enable('policy_abc123')

Webhooks

# Create webhook
webhook = mppfi.webhooks.create(
    url='https://example.com/webhooks/mppfi',
    description='Production webhook endpoint',
    events=[
        'payment.completed',
        'payment.failed',
        'agent.balance.low',
        'policy.violated'
    ],
    enabled=True
)

# Save the signing secret securely
print(f"Signing secret: {webhook.signing_secret}")

# Verify webhook signature (in your webhook handler)
from mppfi import verify_webhook_signature

def handle_webhook(request):
    try:
        event = verify_webhook_signature(
            request.body,
            request.headers.get('X-MPPFi-Signature'),
            os.environ.get('WEBHOOK_SECRET')
        )

        # Handle event
        if event.type == 'payment.completed':
            print(f"Payment completed: {event.data['payment']['id']}")
        elif event.type == 'policy.violated':
            print(f"Policy violation: {event.data['policy']['id']}")

        return {'received': True}
    except ValueError:
        return {'error': 'Invalid signature'}, 401

Error Handling

from mppfi.errors import (
    MPPFiError,
    InsufficientBalanceError,
    PolicyViolationError,
    AuthenticationError,
    RateLimitError,
    NotFoundError
)

try:
    payment = mppfi.payments.create(
        agent_id='agent_7x8y9z',
        amount='10000.00',
        merchant_id='merchant_abc123'
    )
except InsufficientBalanceError:
    print("Agent has insufficient balance")
except PolicyViolationError as e:
    print(f"Policy violation: {e.policy_id}")
    print(f"Reason: {e.reason}")
except AuthenticationError:
    print("Invalid API key")
except RateLimitError as e:
    print(f"Rate limit exceeded. Retry after {e.retry_after}s")
except NotFoundError:
    print("Resource not found")
except MPPFiError as e:
    print(f"MPPFi error: {e.message}")
    print(f"Request ID: {e.request_id}")
except Exception as e:
    print(f"Unexpected error: {e}")

---

Rust SDK

Initialization

use mppfi::{MPPFi, Config};
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mppfi = MPPFi::new(Config {
        api_key: env::var("MPPFI_API_KEY")?,
        environment: "production".to_string(),
        timeout: Some(30),
        max_retries: Some(3),
        solana_rpc: Some("https://api.mainnet-beta.solana.com".to_string()),
    });

    Ok(())
}

Agent Accounts

use mppfi::types::{AgentCreateParams, PolicyRule};

// Create agent account
let agent = mppfi.agents().create(AgentCreateParams {
    name: "Order Processing Agent".to_string(),
    description: Some("Handles automated purchase orders".to_string()),
    initial_balance: Some("1000.00".to_string()),
    policies: Some(vec![
        PolicyRule::AmountLimit {
            max_transaction: "500.00".to_string(),
            max_daily: "5000.00".to_string(),
        }
    ]),
    metadata: Some(serde_json::json!({
        "environment": "production",
        "version": "2.1.0"
    })),
}).await?;

println!("Agent created with Solana address: {}", agent.solana_address);

// List agents
let agents = mppfi.agents().list()
    .limit(20)
    .status("active")
    .send()
    .await?;

// Retrieve agent
let agent = mppfi.agents().retrieve("agent_7x8y9z").await?;

// Get balance
let balance = mppfi.agents().get_balance("agent_7x8y9z").await?;
println!("Available: {} {}", balance.available, balance.currency);

Payments (Machine Payments Protocol)

use mppfi::types::{PaymentCreateParams, MPPProtocol};

// Create MPP payment
let payment = mppfi.payments().create(PaymentCreateParams {
    agent_id: "agent_7x8y9z".to_string(),
    amount: "150.50".to_string(),
    currency: "USDC".to_string(),
    merchant_id: "merchant_abc123".to_string(),
    description: Some("API subscription - March 2026".to_string()),
    mpp_protocol: Some(MPPProtocol {
        version: "1.0".to_string(),
        service_code: "api_access".to_string(),
        authorization_method: "cryptographic_signature".to_string(),
    }),
    metadata: Some(serde_json::json!({
        "order_id": "ORD-2026-03-001"
    })),
    idempotency_key: Some("payment_20260330_001".to_string()),
}).await?;

// Access blockchain details
println!("Transaction signature: {}", payment.blockchain.transaction_signature);
println!("Block explorer: {}", payment.blockchain.explorer_url);

// List payments
let payments = mppfi.payments().list()
    .agent_id("agent_7x8y9z")
    .status("completed")
    .limit(50)
    .send()
    .await?;

for payment in payments.data {
    println!("{}: ${}", payment.merchant_name, payment.amount);
}

Policies (On-Chain Enforcement)

use mppfi::types::{PolicyCreateParams, PolicyRule};

// Create policy
let policy = mppfi.policies().create(PolicyCreateParams {
    agent_id: "agent_7x8y9z".to_string(),
    name: "Daily Spending Limit".to_string(),
    description: Some("Restrict agent to $5,000 daily spending".to_string()),
    rules: vec![
        PolicyRule::AmountLimit {
            max_transaction: "500.00".to_string(),
            max_daily: "5000.00".to_string(),
        },
        PolicyRule::MerchantAllowlist {
            allowed_merchants: vec![
                "merchant_abc123".to_string(),
                "merchant_def456".to_string(),
            ],
        },
    ],
    enforcement: "on_chain".to_string(),
    priority: Some(1),
}).await?;

// Policy is deployed to Solana
println!("Policy deployed at: {}", policy.blockchain.program_address);

Error Handling

use mppfi::errors::{MPPFiError, ErrorType};

match mppfi.payments().create(params).await {
    Ok(payment) => println!("Payment created: {}", payment.id),
    Err(e) => match e {
        MPPFiError::InsufficientBalance { .. } => {
            eprintln!("Agent has insufficient balance");
        }
        MPPFiError::PolicyViolation { policy_id, reason, .. } => {
            eprintln!("Policy violation: {}", policy_id);
            eprintln!("Reason: {}", reason);
        }
        MPPFiError::Authentication { .. } => {
            eprintln!("Invalid API key");
        }
        MPPFiError::RateLimit { retry_after, .. } => {
            eprintln!("Rate limit exceeded. Retry after {}s", retry_after);
        }
        MPPFiError::NotFound { .. } => {
            eprintln!("Resource not found");
        }
        _ => eprintln!("Unexpected error: {}", e),
    },
}

---

Go SDK

Initialization

package main

import (
    "github.com/mppfi/mppfi-go"
    "os"
    "time"
)

func main() {
    client := mppfi.NewClient(&mppfi.Config{
        APIKey:      os.Getenv("MPPFI_API_KEY"),
        Environment: "production",
        Timeout:     30 * time.Second,
        MaxRetries:  3,
        SolanaRPC:   "https://api.mainnet-beta.solana.com",
    })
}

Agent Accounts

// Create agent account
agent, err := client.Agents.Create(&mppfi.AgentCreateParams{
    Name:           "Order Processing Agent",
    Description:    "Handles automated purchase orders",
    InitialBalance: "1000.00",
    Policies: []mppfi.PolicyRule{
        {
            Type:           "amount_limit",
            MaxTransaction: "500.00",
            MaxDaily:       "5000.00",
        },
    },
    Metadata: map[string]interface{}{
        "environment": "production",
        "version":     "2.1.0",
    },
})
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Agent created with Solana address: %s\n", agent.SolanaAddress)

// List agents
agents, err := client.Agents.List(&mppfi.AgentListParams{
    Limit:  20,
    Status: "active",
})

// Retrieve agent
agent, err := client.Agents.Retrieve("agent_7x8y9z")

// Get balance
balance, err := client.Agents.GetBalance("agent_7x8y9z")
fmt.Printf("Available: %s %s\n", balance.Available, balance.Currency)

Payments (Machine Payments Protocol)

// Create MPP payment
payment, err := client.Payments.Create(&mppfi.PaymentCreateParams{
    AgentID:     "agent_7x8y9z",
    Amount:      "150.50",
    Currency:    "USDC",
    MerchantID:  "merchant_abc123",
    Description: "API subscription - March 2026",
    MPPProtocol: &mppfi.MPPProtocol{
        Version:             "1.0",
        ServiceCode:         "api_access",
        AuthorizationMethod: "cryptographic_signature",
    },
    Metadata: map[string]interface{}{
        "order_id": "ORD-2026-03-001",
    },
    IdempotencyKey: "payment_20260330_001",
})

// Access blockchain details
fmt.Printf("Transaction signature: %s\n", payment.Blockchain.TransactionSignature)
fmt.Printf("Block explorer: %s\n", payment.Blockchain.ExplorerURL)

// List payments
payments, err := client.Payments.List(&mppfi.PaymentListParams{
    AgentID: "agent_7x8y9z",
    Status:  "completed",
    Limit:   50,
})

for _, payment := range payments.Data {
    fmt.Printf("%s: $%s\n", payment.MerchantName, payment.Amount)
}

Error Handling

payment, err := client.Payments.Create(params)
if err != nil {
    switch e := err.(type) {
    case *mppfi.InsufficientBalanceError:
        log.Println("Agent has insufficient balance")
    case *mppfi.PolicyViolationError:
        log.Printf("Policy violation: %s\n", e.PolicyID)
        log.Printf("Reason: %s\n", e.Reason)
    case *mppfi.AuthenticationError:
        log.Println("Invalid API key")
    case *mppfi.RateLimitError:
        log.Printf("Rate limit exceeded. Retry after %d seconds\n", e.RetryAfter)
    case *mppfi.NotFoundError:
        log.Println("Resource not found")
    default:
        log.Printf("Unexpected error: %v\n", err)
    }
}

---

SDK Support

Versioning

SDKs follow semantic versioning. Check your current version:

# TypeScript
npm list @mppfi/node

# Python
pip show mppfi

# Rust
cargo tree | grep mppfi

# Go
go list -m github.com/mppfi/mppfi-go

Updates

Stay up to date with the latest SDK releases:

# TypeScript
npm update @mppfi/node

# Python
pip install --upgrade mppfi

# Rust
cargo update mppfi

# Go
go get -u github.com/mppfi/mppfi-go

Source Code

SDKs are open source:

• TypeScript: github.com/mppfi/mppfi-node

• Python: github.com/mppfi/mppfi-python

• Rust: github.com/mppfi/mppfi-rust

• Go: github.com/mppfi/mppfi-go

Community SDKs

Community-maintained SDKs:

• Ruby: mppfi-ruby (unofficial)

• PHP: mppfi-php (unofficial)

• Java: mppfi-java (unofficial)

Note: Community SDKs are not officially supported by MPPFi.

---

Next Steps

• API Reference - Complete REST API documentation

• Quickstart Guide - Get started in 5 minutes

• Webhooks - Real-time event notifications

• Error Reference - Complete error code guide

• Architecture - System architecture details

---

Support

• Documentation: https://docs.mppfi.xyz

• GitHub Issues: Report SDK bugs on respective repositories

• Discord Community: https://discord.gg/mppfi

• Support Email: [email protected]