Payment Simulator

Test your payment integration in a safe sandbox environment

Safe Testing Environment

Test payment flows without any real transactions or money involved

Generate QRIS Codes

Create test QRIS payment codes with customizable amounts and details

Simulate Payments

Simulate payment completion and trigger callbacks to your server

Monitor Status

Track payment status and callback delivery in real-time

🚀 Ready to Test?

Open Payment Simulator

The simulator is fully functional and ready for development testing. All payments created here are in sandbox mode.

Overview

The Payment Simulator is a secure sandbox environment where you can test your payment integration before going live. You can create test QRIS payments, simulate payment completion, and verify that your callback handlers work correctly.

Key Features

No real money transactions
Instant payment simulation
Real callback delivery to your registered endpoints
Full webhook simulation with retry logic
Payment history and tracking
Support for all payment methods (QRIS, VA, etc)
Customizable customer details
Detailed transaction logs

Getting Started

1 Access the Simulator

Visit https://cicis.online/simulator to open the payment simulator interface.

2 Create a Test Payment

Fill in the payment form with test details:

Order ID (any unique identifier for testing)
Amount (in IDR)
Customer Name
Customer Email
Customer Phone
Callback URL (your endpoint URL)

3 Generate QRIS Code

The simulator generates a QRIS QR code that you can scan or display in your application. This is identical to production QR codes.

4 Simulate Payment

Click the "Simulate Payment" button to instantly mark the payment as completed. This triggers a real callback to your registered endpoint.

5 Verify Your Integration

Check your server logs to confirm that the callback was received and processed correctly. Verify that your order status was updated.

Testing Workflow

1. You access https://cicis.online/simulator 2. You fill in payment details and register your callback URL 3. Simulator creates QRIS QR code 4. You click "Simulate Payment" 5. Simulator marks payment as complete in database 6. Simulator sends real HTTP POST to your callback URL 7. Your application receives payment notification 8. Your application updates order status 9. Simulator shows "Callback Delivered" status

Creating Test Payments via API

You can also create test payments programmatically using the regular payment API. The simulator works with the same endpoints as production.

# Create a test QRIS payment
curl -X POST https://cicis.online/api/qris/initiate \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 50000,
    "order_id": "TEST-001",
    "customer_name": "Test Customer",
    "customer_email": "test@example.com",
    "customer_phone": "+6281234567890",
    "callback_url": "https://yourdomain.com/payment-callback",
    "description": "Test Payment"
  }'

# Check payment status
curl -X GET "https://cicis.online/api/qris/check-status/TEST-001" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

const axios = require('axios');

// Create test payment
async function createTestPayment() {
    try {
        const response = await axios.post(
            'https://cicis.online/api/qris/initiate',
            {
                amount: 50000,
                order_id: 'TEST-001',
                customer_name: 'Test Customer',
                customer_email: 'test@example.com',
                customer_phone: '+6281234567890',
                callback_url: 'https://yourdomain.com/payment-callback',
                description: 'Test Payment'
            },
            {
                headers: {
                    'Authorization': 'Bearer YOUR_ACCESS_TOKEN'
                }
            }
        );
        
        console.log('Payment created:', response.data);
        return response.data;
    } catch (error) {
        console.error('Error:', error.response.data);
    }
}

// Check payment status
async function checkPaymentStatus(orderId) {
    try {
        const response = await axios.get(
            `https://cicis.online/api/qris/check-status/${orderId}`,
            {
                headers: {
                    'Authorization': 'Bearer YOUR_ACCESS_TOKEN'
                }
            }
        );
        
        console.log('Payment status:', response.data);
        return response.data;
    } catch (error) {
        console.error('Error:', error.response.data);
    }
}

Payment created: nullPayment status: null

import requests
import json

API_TOKEN = 'YOUR_ACCESS_TOKEN'
BASE_URL = 'https://cicis.online/api'

headers = {
    'Authorization': f'Bearer {API_TOKEN}',
    'Content-Type': 'application/json'
}

# Create test payment
def create_test_payment():
    payload = {
        'amount': 50000,
        'order_id': 'TEST-001',
        'customer_name': 'Test Customer',
        'customer_email': 'test@example.com',
        'customer_phone': '+6281234567890',
        'callback_url': 'https://yourdomain.com/payment-callback',
        'description': 'Test Payment'
    }
    
    response = requests.post(
        f'{BASE_URL}/qris/initiate',
        json=payload,
        headers=headers
    )
    
    print('Payment created:')
    print(json.dumps(response.json(), indent=2))
    return response.json()

# Check payment status
def check_payment_status(order_id):
    response = requests.get(
        f'{BASE_URL}/qris/check-status/{order_id}',
        headers=headers
    )
    
    print('Payment status:')
    print(json.dumps(response.json(), indent=2))
    return response.json()

# Usage
if __name__ == '__main__':
    create_test_payment()
    check_payment_status('TEST-001')

Simulating Payment Completion

Once you have a QRIS code generated, you can simulate payment completion:

# Simulate payment completion (triggers callback)
curl -X POST https://cicis.online/simulator/simulate-payment \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "order_id": "TEST-001"
  }'

// Simulate payment completion
async function simulatePayment(orderId) {
    try {
        const response = await axios.post(
            'https://cicis.online/simulator/simulate-payment',
            { order_id: orderId },
            {
                headers: {
                    'Authorization': 'Bearer YOUR_ACCESS_TOKEN'
                }
            }
        );
        
        console.log('Payment simulated:', response.data);
        return response.data;
    } catch (error) {
        console.error('Error:', error.response.data);
    }
}

// Usage
simulatePayment('TEST-001');

Payment simulated: null

Testing Callback Delivery

Use these tools to verify your callback endpoint is working correctly:

ngrok (Tunnel)

Create a public URL for your localhost:

ngrok http 8000

Webhook.site

Get a unique URL to capture and inspect requests from the simulator

Server Logs

Check your application logs for incoming callback requests

Database

Verify callback_sent_at timestamp and callback_response in winpay_orders table

⚠️ Callback URL Requirements

Must be publicly accessible (not localhost)
Must use HTTPS (recommended)
Must return HTTP 200 OK status
Response should be returned within 30 seconds
Should be idempotent (same callback can be sent multiple times)

Test Scenarios

Recommended Test Cases

Basic Payment: Create payment, simulate completion, verify callback received
Callback Retry: Test endpoint that returns error, verify automatic retries
Duplicate Processing: Send callback twice, verify order not duplicated
Various Amounts: Test with different payment amounts
Customer Details: Verify customer info is correctly passed in callback
Email Notifications: Confirm confirmation emails are sent
Order Status: Verify order transitions from pending to completed
Error Handling: Test your error handling for malformed requests

Viewing Payment History

In the Payment Simulator, you can view a complete history of all test payments created, including:

Order ID and amount
Customer details
Payment status (pending, completed, failed)
QRIS QR code
Callback URL and delivery status
Timestamp of creation and completion
Full callback request and response logs

Debugging Callbacks

Verify callback_url is correctly formatted and publicly accessible
Check that your URL is reachable: curl https://yourdomain.com/callback
Verify DNS resolution: nslookup yourdomain.com
Check firewall/network ACLs allow inbound requests
Check application logs for incoming webhook requests
If testing locally, use ngrok or Webhook.site for public URL

Ensure callback handler returns quickly (within 5 seconds)
Move long-running tasks to background jobs
Check application performance and server response times
Verify network connectivity to your server
Check for database locks or slow queries

Check that endpoint returns HTTP 200 status code
Verify JSON payload is being parsed correctly
Check for PHP errors or exceptions in application logs
Verify database connectivity in callback handler
Test manually with Postman or cURL using callback payload
Add logging statements to track execution flow

# Download and run ngrok
./ngrok http 8000

# This gives you a public URL like:
# https://abc123.ngrok.io

# Use this in your callback URL:
# https://abc123.ngrok.io/payment-callback

# View incoming requests at:
# http://localhost:4040

Comparison: Simulator vs Production

Feature	Simulator	Production
Real Transactions	No	Yes
QRIS Generation	Yes	Yes
Payment Simulation	Yes	No (Real payments)
Callback Delivery	Yes	Yes
Webhook Signing	Yes	Yes
Retry Logic	Yes	Yes
Error Scenarios	Limited	All Types
Rate Limits	No	Yes

Next Steps

Read the Callback & Webhooks documentation
Set up your callback endpoint
Open the Payment Simulator
Create a test payment with your callback URL
Simulate payment completion
Verify callback is received and processed
Check your order status is updated correctly
Test error handling and retries
Deploy to production with confidence!

✅ Ready to Go Live?

Once you've thoroughly tested your integration in the simulator:

Switch to production credentials in your environment
Update callback URLs to production domain
Deploy your application
Monitor first few payments in real-world usage
Have a plan for handling payment issues

Need Help?

For additional support with the payment simulator, please visit our Support Page or contact our development team.