API Console
$ curl -X POST https://api.vasgo.com/v1/payments \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 1000,
    "currency": "USD",
    "payment_method": "card",
    "card": {
      "number": "4242424242424242",
      "exp_month": 12,
      "exp_year": 2025,
      "cvc": "123"
    }
  }'
Processing payment...
{
  "id": "pay_1N2fG7JK8zHd9L",
  "object": "payment",
  "amount": 1000,
  "currency": "USD",
  "status": "succeeded",
  "created": 1682541234
}
Payment APIs

vasGO API

Our vasGO API enables businesses and developers to easily integrate secure, real-time payment systems into their websites, mobile applications, and custom-built platforms, ensuring smooth and secure payment experiences.

With comprehensive documentation, SDKs for multiple programming languages, and a robust testing environment, you can implement payment functionality in minutes, not days.

Key Features

Powerful API Capabilities

Discover the powerful features that make vasGO API the preferred payment solution for developers.

Easy Integration

Seamless Implementation in Minutes

Seamlessly add payment functionality to your mobile apps, websites, or custom platforms with minimal hassle.

  • Plug-and-Play Setup - Embed pre-built, PCI-compliant payment modules (cards/digital wallets/crypto) in <1 hour with low-code APIs—works with any tech stack.
  • Smart Routing & Retries - AI dynamically selects payment gateways based on cost/success rates, and auto-retries failed transactions in milliseconds (boosts approvals by 12%).
  • Real-Time Fraud Screening - Machine learning blocks 99.7% of fraudulent transactions while reducing false declines—analyzing 150+ risk signals per payment.
  • Automated Reconciliation - AI matches incoming payments with invoices/orders instantly, cutting accounting errors by 90% and speeding month-end closes.
JavaScript
// Initialize the vasGO API client
const vasgo = require('vasgo-node');
const client = new vasgo.Client('YOUR_API_KEY');

// Create a payment
async function createPayment() {
  try {
    const payment = await client.payments.create({
      amount: 2500, // $25.00
      currency: 'USD',
      payment_method: 'card',
      card: {
        token: 'tok_visa' // Use a token from your secure form
      },
      description: 'Order #1234',
      metadata: {
        order_id: '1234',
        customer_id: '5678'
      }
    });
    
    console.log('Payment successful:', payment.id);
    return payment;
  } catch (error) {
    console.error('Payment failed:', error.message);
    throw error;
  }
}

Real-Time Payment Processing

Instant Transaction Updates

Instantly receive transaction updates and payment confirmations through our powerful API system.

  • Instant Transaction Visibility - Get payment confirmations in <500ms via webhooks/API—with live status tracking for every card, wallet, and bank transfer.
  • Smart Failure Recovery - AI predicts and resolves 65% of declined payments in real-time by auto-switching gateways or nudging buyers to retry.
  • Global Settlement Speed - Process cross-border payments in seconds (not days) using AI-optimized routing through local rails and FX networks.
  • Embedded Compliance - Automatically screens transactions against 50+ global sanctions lists while generating audit trails for regulators.
POST /v1/payments

Create a new payment and process it immediately.

Request Parameters:

amount integer required

Amount to charge in the smallest currency unit (e.g., cents for USD).

currency string required

Three-letter ISO currency code (e.g., USD, EUR).

payment_method string required

Payment method type (card, bank_transfer, wallet, etc.).

description string optional

Description of the payment that appears on statements.

GET /v1/payments/{payment_id}

Retrieve details of a specific payment.

Secure & Compliant

Enterprise-Grade Security

We provide robust encryption and compliance with global security standards to safeguard all payment transactions.

  • Military-Grade Encryption - All transactions secured with AES-256 + tokenization, ensuring card/PII data is never exposed—even during processing.
  • AI-Powered Fraud Defense - Real-time machine learning analyzes 200+ behavioral/device signals to block fraud while reducing false declines by 40%.
  • Automated Compliance - Pre-certified for PCI-DSS Level 1, GDPR, and PSD2/SCA—with self-updating protocols for new regulations.
  • Blockchain Audit Trails - Immutable transaction logs provide end-to-end visibility, simplifying disputes and regulatory reporting.
Python
# Secure payment processing with tokenization
import vasgo

# Initialize the client with your API key
client = vasgo.Client(api_key="YOUR_API_KEY")

# Create a payment token (on your secure server)
# This keeps sensitive card data off your servers
def create_payment_token(card_details):
    try:
        token = client.tokens.create(
            card_number=card_details["number"],
            exp_month=card_details["exp_month"],
            exp_year=card_details["exp_year"],
            cvc=card_details["cvc"]
        )
        return token.id
    except vasgo.error.SecurityError as e:
        print(f"Security validation failed: {e}")
        return None

# Process payment with the token
def process_payment(amount, currency, token):
    try:
        # Apply 3D Secure authentication if required
        payment = client.payments.create(
            amount=amount,
            currency=currency,
            payment_method="card",
            token=token,
            security={
                "3d_secure": True,
                "fraud_detection": "enhanced"
            }
        )
        return payment
    except vasgo.error.PaymentError as e:
        print(f"Payment failed: {e}")
        return None

Developer-Friendly Documentation

Comprehensive Resources

Comprehensive guides, tools, and support make integration simple and efficient for developers.

  • Intelligent API Documentation - Interactive guides with real-time code samples (in Python, Node.js, Java) that auto-adjust to your SDK version—cutting integration time by 50%.
  • AI-Powered Debugging - Our developer assistant bot diagnoses API errors instantly, suggesting fixes with 90% accuracy based on 10M+ past integrations.
  • Sandbox with Smart Test Data - Self-populating test environment generates realistic payment scenarios (declines/chargebacks/3DS flows) to accelerate QA cycles.
  • One-Click Live Mode - Shift from testing to production with automated compliance checks—no reconfiguration needed.
Developer Documentation
API Reference

Core API Endpoints

Explore the key endpoints that power our payment processing system.

POST /v1/payments

Create a new payment and process it immediately.

GET /v1/payments/{payment_id}

Retrieve details of a specific payment.

POST /v1/refunds

Create a refund for a previously processed payment.

POST /v1/payment_methods

Create a reusable payment method that can be attached to customers.

POST /v1/customers

Create a customer record to store payment methods and transaction history.

POST /v1/webhooks

Configure webhook endpoints to receive real-time payment event notifications.

Developer Experience

Simple Integration in Minutes

Our API is designed with developers in mind, making integration straightforward with clean, intuitive code.


// Initialize the vasGO API client
const vasgo = require('vasgo-api')('your_api_key');

// Create a payment
async function createPayment() {
try {
const payment = await vasgo.payments.create({
  amount: 1000, // Amount in cents
  currency: 'USD',
  description: 'Order #12345',
  customer: {
    email: 'customer@example.com',
    name: 'John Doe'
  },
  payment_method_types: ['card', 'mobile_money', 'bank_transfer'],
  success_url: 'https://yourwebsite.com/success',
  cancel_url: 'https://yourwebsite.com/cancel'
});

console.log('Payment created:', payment.id);
return payment;
} catch (error) {
console.error('Error creating payment:', error);
}
}

// Process the payment
createPayment().then(payment => {
// Redirect to the payment page or use the payment token
window.location.href = payment.checkout_url;
});
                                

# Initialize the vasGO API client
import vasgo
vasgo.api_key = "your_api_key"

# Create a payment
def create_payment():
try:
    payment = vasgo.Payment.create(
        amount=1000,  # Amount in cents
        currency="USD",
        description="Order #12345",
        customer={
            "email": "customer@example.com",
            "name": "John Doe"
        },
        payment_method_types=["card", "mobile_money", "bank_transfer"],
        success_url="https://yourwebsite.com/success",
        cancel_url="https://yourwebsite.com/cancel"
    )
    
    print(f"Payment created: {payment.id}")
    return payment
except Exception as e:
    print(f"Error creating payment: {e}")

# Process the payment
payment = create_payment()
if payment:
# Redirect to the payment page or use the payment token
print(f"Redirect user to: {payment.checkout_url}")
                                

// Initialize the vasGO API client
require_once('vendor/autoload.php');
\VasGO\API::setApiKey('your_api_key');

// Create a payment
function createPayment() {
try {
    $payment = \VasGO\Payment::create([
        'amount' => 1000, // Amount in cents
        'currency' => 'USD',
        'description' => 'Order #12345',
        'customer' => [
            'email' => 'customer@example.com',
            'name' => 'John Doe'
        ],
        'payment_method_types' => ['card', 'mobile_money', 'bank_transfer'],
        'success_url' => 'https://yourwebsite.com/success',
        'cancel_url' => 'https://yourwebsite.com/cancel'
    ]);
    
    echo "Payment created: " . $payment->id;
    return $payment;
} catch (\Exception $e) {
    echo "Error creating payment: " . $e->getMessage();
}
}

// Process the payment
$payment = createPayment();
if ($payment) {
// Redirect to the payment page or use the payment token
header("Location: " . $payment->checkout_url);
exit();
}
                                

// Initialize the vasGO API client
import com.vasgo.api.VasGO;
import com.vasgo.api.model.Payment;
import com.vasgo.api.exception.VasGOException;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class PaymentExample {
public static void main(String[] args) {
    VasGO.apiKey = "your_api_key";
    
    try {
        // Create customer details
        Map customer = new HashMap<>();
        customer.put("email", "customer@example.com");
        customer.put("name", "John Doe");
        
        // Create a payment
        Map params = new HashMap<>();
        params.put("amount", 1000); // Amount in cents
        params.put("currency", "USD");
        params.put("description", "Order #12345");
        params.put("customer", customer);
        params.put("payment_method_types", Arrays.asList("card", "mobile_money", "bank_transfer"));
        params.put("success_url", "https://yourwebsite.com/success");
        params.put("cancel_url", "https://yourwebsite.com/cancel");
        
        Payment payment = Payment.create(params);
        
        System.out.println("Payment created: " + payment.getId());
        System.out.println("Redirect user to: " + payment.getCheckoutUrl());
        
    } catch (VasGOException e) {
        System.err.println("Error creating payment: " + e.getMessage());
    }
}
}
                                
Process

How vasGO API Integration Works

A simple, straightforward process to integrate payments into your application.

1

Sign Up & Get API Keys

Create a vasGO account and obtain your API keys from the developer dashboard.

2

Install SDK

Install our SDK for your preferred programming language using package managers like npm, pip, or composer.

3

Integrate API

Add a few lines of code to your application to create and process payments using our API.

4

Test & Go Live

Test your integration in our sandbox environment, then switch to production when you're ready to go live.

Use Cases

Perfect For Your Business

Discover how vasGO API can transform payment experiences across different business types.

Mobile App Developers

Add integrated payment solutions to mobile apps without the need to develop from scratch. Our SDK provides pre-built UI components and secure payment flows that can be implemented with just a few lines of code.

// Swift example for iOS apps
import VasGoSDK

// Initialize the SDK
VasGo.initialize(apiKey: "YOUR_API_KEY")

// Show payment sheet
let paymentSheet = VasGo.PaymentSheet(
    amount: 2500,
    currency: "USD",
    merchantName: "Your App Name"
)

paymentSheet.present(from: self) { result in
    switch result {
    case .completed:
        // Payment successful
    case .failed(let error):
        // Handle error
    case .canceled:
        // User canceled
    }
}

E-Commerce Platforms

Enable secure online transactions with ease. Our API integrates seamlessly with popular e-commerce platforms and shopping carts, providing a smooth checkout experience for your customers.

// PHP example for e-commerce sites
require_once('vendor/autoload.php');

// Initialize the client
$vasgo = new \VasGo\Client('YOUR_API_KEY');

// Create a checkout session
$session = $vasgo->checkoutSessions->create([
    'success_url' => 'https://yourstore.com/success',
    'cancel_url' => 'https://yourstore.com/cancel',
    'line_items' => [
        [
            'name' => 'Premium Headphones',
            'amount' => 9999,
            'currency' => 'USD',
            'quantity' => 1
        ]
    ],
    'payment_method_types' => ['card', 'wallet']
]);

// Redirect to checkout
header("Location: " . $session->checkout_url);

FinTech Startups

Build customized payment gateways that fit your unique business needs. Our flexible API allows you to create innovative financial products and services with robust payment capabilities.

// Node.js example for FinTech platforms
const { VasGo } = require('vasgo-node');
const express = require('express');
const app = express();

// Initialize the client
const vasgo = new VasGo('YOUR_API_KEY');

// Create a payment link
app.post('/create-payment-link', async (req, res) => {
  try {
    const link = await vasgo.paymentLinks.create({
      amount: req.body.amount,
      currency: req.body.currency,
      description: req.body.description,
      expires_at: Math.floor(Date.now() / 1000) + 3600, // 1 hour
      metadata: {
        customer_id: req.body.customer_id
      }
    });
    
    res.json({ url: link.url });
  } catch (error) {
    res.status(400).json({ error: error.message });
  }
});
Pricing

Transparent API Pricing

Simple, predictable pricing with no hidden fees.

Starter

$ 0 /month

2.9% + $0.30 per transaction

  • Up to 1,000 API calls/month
  • Standard payment methods
  • Basic fraud protection
  • Email support
  • Sandbox testing environment
  • Standard documentation

Enterprise

Custom

Volume-based pricing

  • Unlimited API calls
  • All payment methods
  • AI-powered fraud protection
  • Dedicated account manager
  • 24/7 premium support
  • Custom integrations
  • Advanced analytics
  • SLA guarantees
FAQ

Frequently Asked Questions

Find answers to common questions about vasGO API.

Most developers can integrate vasGO API in less than a day. Our pre-built SDKs and comprehensive documentation make it easy to get started. Simple payment forms can be implemented in as little as 30 minutes, while more complex integrations with custom workflows might take a few hours. Our developer support team is also available to assist with any integration challenges you might encounter.

vasGO API offers official SDKs for JavaScript (Node.js), Python, PHP, Ruby, Java, and .NET. We also provide comprehensive REST API documentation that allows integration with any programming language that can make HTTP requests. Our SDKs are regularly updated and maintained to ensure compatibility with the latest language versions and frameworks.

Yes, vasGO API is PCI DSS Level 1 certified, which is the highest level of compliance. Our tokenization system ensures that sensitive card data never touches your servers, significantly reducing your PCI compliance burden. By using our secure payment elements and following our integration guidelines, you can maintain a simplified PCI compliance posture while still offering a seamless payment experience to your customers.

vasGO API supports a wide range of payment methods including credit/debit cards (Visa, Mastercard, American Express, Discover, etc.), digital wallets (Apple Pay, Google Pay, PayPal), bank transfers (ACH, SEPA, wire transfers), mobile money services (M-Pesa, Orange Money), and cryptocurrencies (Bitcoin, Ethereum). We're constantly adding new payment methods to ensure global coverage and provide your customers with their preferred payment options.

Our sandbox environment is a complete replica of the production environment, allowing you to test your integration thoroughly before going live. It includes test API keys, test card numbers for different scenarios (successful payments, declines, 3D Secure authentication), and simulated payment flows. You can also test webhooks, refunds, disputes, and other advanced features. The sandbox automatically generates realistic test data to help you validate your integration under various conditions.

Ready to Integrate Payments?

Join thousands of developers who have transformed their payment experience with vasGO API's powerful solutions.