Dashboard Reporting Overview

The Omise Dashboard provides comprehensive reporting and analytics tools to help you monitor, analyze, and optimize your payment operations. Access real-time data, generate custom reports, and export insights for accounting, reconciliation, and business intelligence.

Overview

The Omise Dashboard reporting suite offers:

Real-time Analytics: Monitor payment activity as it happens
Customizable Reports: Filter and segment data by various parameters
Multiple Export Formats: Download reports in CSV, PDF, or Excel
Scheduled Reports: Automate report generation and delivery
Multi-currency Support: View reports in multiple currencies
Team Permissions: Control access to sensitive financial data
API Integration: Access report data programmatically
Historical Data: Access up to 7 years of transaction history

Accessing Reports

Login to Dashboard
- Navigate to https://dashboard.omise.co
- Enter your credentials
- Complete two-factor authentication if enabled
Main Navigation
- Home: Overview dashboard with key metrics
- Transactions: Detailed payment transaction reports
- Balance: Account balance and settlement information
- Reports: Custom report generation
- Analytics: Advanced analytics and insights
Quick Access
- Use the search bar (Ctrl/Cmd + K) for quick navigation
- Bookmark frequently used report pages
- Create custom dashboard views

Dashboard Layout

┌─────────────────────────────────────────────────────┐
│ Omise Dashboard              [Search] [Profile] [?] │
├──────────────┬──────────────────────────────────────┤
│ Navigation   │                                       │
│ • Home       │  Report Content Area                  │
│ • Payments   │  - Metrics and KPIs                   │
│ • Balance    │  - Charts and graphs                  │
│ • Reports    │  - Data tables                        │
│ • Analytics  │  - Export options                     │
│ • Settings   │                                       │
└──────────────┴──────────────────────────────────────┘

Available Reports

Standard Reports

The dashboard provides several pre-configured report types:

1. Transaction Reports

Payment Reports: All successful payments
Charge Reports: All charge attempts (successful and failed)
Refund Reports: All refund transactions
Dispute Reports: Chargebacks and disputes
Transfer Reports: Payouts and transfers

2. Balance Reports

Balance History: Account balance over time
Settlement Reports: Detailed settlement breakdowns
Payout Reports: Bank transfer information
Fee Reports: Transaction and service fees
Reserve Reports: Reserve balance tracking

3. Performance Reports

Conversion Reports: Success rates and trends
Payment Method Reports: Performance by payment method
Currency Reports: Multi-currency transaction analysis
Geographic Reports: Payments by country/region
Time-based Reports: Hourly, daily, weekly, monthly trends

4. Customer Reports

Customer Analytics: Customer payment behavior
Recurring Reports: Subscription and recurring payment metrics
Card Reports: Card usage and performance
Token Reports: Token creation and usage

Date Filtering

Standard Date Ranges

Select from predefined date ranges for quick access:

Today: Current day (00:00 - 23:59 in your timezone)
Yesterday: Previous day
Last 7 Days: Past week including today
Last 30 Days: Past month including today
This Month: Current calendar month
Last Month: Previous calendar month
This Quarter: Current fiscal quarter
Last Quarter: Previous fiscal quarter
This Year: Current calendar year
Last Year: Previous calendar year
All Time: Complete transaction history

Custom Date Ranges

Create custom date ranges for specific reporting needs:

Select Date Range

From: [MM/DD/YYYY] [HH:MM]
To:   [MM/DD/YYYY] [HH:MM]

Apply Filters
- Click "Apply" to update the report
- Click "Save" to save as a custom range
- Use keyboard shortcuts (D for date picker)
Date Range Limits
- Maximum range: 1 year per query
- For longer periods, use multiple queries
- API access allows programmatic historical queries

Date Filter Examples

// Common date filter patterns

// Last 30 days
const dateFilter = {
  from: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000),
  to: new Date()
};

// Specific month
const monthFilter = {
  from: new Date('2024-01-01T00:00:00Z'),
  to: new Date('2024-01-31T23:59:59Z')
};

// Quarter
const quarterFilter = {
  from: new Date('2024-01-01T00:00:00Z'),
  to: new Date('2024-03-31T23:59:59Z')
};

// Custom range
const customFilter = {
  from: new Date('2024-02-15T00:00:00Z'),
  to: new Date('2024-03-15T23:59:59Z')
};

Timezone Handling

Dashboard Timezone Settings

Configure timezone settings for accurate reporting:

Account Timezone
- Set in Settings > Account > Timezone
- Applies to all dashboard views
- Affects report timestamps
- Impacts scheduled reports
Supported Timezones
- All standard IANA timezone identifiers
- Common options:
  - Asia/Bangkok (UTC+7)
  - Asia/Singapore (UTC+8)
  - Asia/Tokyo (UTC+9)
  - UTC (Coordinated Universal Time)

Timezone in Reports

Display Format: YYYY-MM-DD HH:MM:SS TZ
Example: 2024-01-15 14:30:00 ICT

API Timezone Configuration

When accessing reports via API, specify timezone in requests:

// Node.js - Fetch transactions with timezone
const omise = require('omise')({
  secretKey: 'skey_test_xxxxx'
});

const transactions = await omise.transactions.list({
  from: '2024-01-01T00:00:00',
  to: '2024-01-31T23:59:59',
  timezone: 'Asia/Bangkok'
});

# Python - Timezone-aware report queries
import omise
from datetime import datetime
import pytz

omise.api_secret = 'skey_test_xxxxx'

# Set timezone
bangkok_tz = pytz.timezone('Asia/Bangkok')
from_date = bangkok_tz.localize(datetime(2024, 1, 1))
to_date = bangkok_tz.localize(datetime(2024, 1, 31, 23, 59, 59))

# Fetch transactions
transactions = omise.Transaction.retrieve(
    from_date=from_date.isoformat(),
    to_date=to_date.isoformat()
)

# Ruby - Timezone handling in reports
require 'omise'
require 'active_support/time'

Omise.api_key = 'skey_test_xxxxx'

# Set timezone
Time.zone = 'Bangkok'

# Query with timezone
transactions = Omise::Transaction.list({
  from: Time.zone.parse('2024-01-01 00:00:00').iso8601,
  to: Time.zone.parse('2024-01-31 23:59:59').iso8601
})

<?php
// PHP - Timezone configuration for reports
require_once 'vendor/autoload.php';

define('OMISE_SECRET_KEY', 'skey_test_xxxxx');

// Set timezone
date_default_timezone_set('Asia/Bangkok');

// Create date range
$from = new DateTime('2024-01-01 00:00:00');
$to = new DateTime('2024-01-31 23:59:59');

// Fetch transactions
$transactions = OmiseTransaction::retrieve([
    'from' => $from->format(DateTime::ATOM),
    'to' => $to->format(DateTime::ATOM)
]);
?>

// Go - Timezone handling in reports
package main

import (
    "time"
    "github.com/omise/omise-go"
    "github.com/omise/omise-go/operations"
)

func main() {
    client, _ := omise.NewClient("pkey_test_xxxxx", "skey_test_xxxxx")
    
    // Load timezone
    location, _ := time.LoadLocation("Asia/Bangkok")
    
    // Create date range
    from := time.Date(2024, 1, 1, 0, 0, 0, 0, location)
    to := time.Date(2024, 1, 31, 23, 59, 59, 0, location)
    
    // Query transactions
    transactions := &omise.TransactionList{}
    client.Do(transactions, &operations.ListTransactions{
        From: from,
        To:   to,
    })
}

Dashboard Permissions

User Roles

Control access to reporting features with role-based permissions:

1. Administrator

Full access to all reports and data
Can export all reports
Can create scheduled reports
Can manage user permissions
Access to sensitive financial data

2. Manager

Access to most reports
Can export standard reports
Can view but not modify settings
Limited access to customer data
Cannot modify permissions

3. Analyst

Read-only access to reports
Can export data for analysis
Cannot modify settings
Limited historical data access
No access to PII

4. Support

Access to transaction lookup
Can view customer payment history
Cannot export bulk data
Cannot access financial reports
Limited to support-related queries

5. Accountant

Full access to financial reports
Can export accounting data
Access to settlement reports
Cannot process transactions
Cannot access customer PII

Permission Configuration

Set up permissions for team members:

Navigate to Settings > Team
Add or Edit User
- Enter email address
- Select role from dropdown
- Set report access level
- Configure export permissions
- Enable/disable API access

Custom Permissions

{
  "role": "custom",
  "permissions": {
    "reports": {
      "transactions": "read",
      "balance": "read",
      "customers": "none",
      "export": true,
      "api_access": false
    },
    "data_access": {
      "pii": false,
      "financial": true,
      "historical_days": 90
    }
  }
}

API Access Control

Configure API access for programmatic reporting:

// Node.js - API key with restricted permissions
const omise = require('omise')({
  secretKey: 'skey_test_xxxxx' // Read-only key
});

// Verify key permissions
omise.account.retrieve()
  .then(account => {
    console.log('Account:', account.email);
    console.log('Capabilities:', account.capabilities);
  })
  .catch(err => {
    console.error('Access denied:', err.message);
  });

Programmatic Report Access

API Overview

Access all dashboard reports programmatically using the Omise API:

// Node.js - Comprehensive report access
const omise = require('omise')({
  secretKey: 'skey_test_xxxxx'
});

async function generateMonthlyReport(year, month) {
  const from = new Date(year, month - 1, 1);
  const to = new Date(year, month, 0, 23, 59, 59);
  
  // Fetch transactions
  const charges = await omise.charges.list({
    from: from.toISOString(),
    to: to.toISOString(),
    limit: 100
  });
  
  // Fetch balance
  const balance = await omise.balance.retrieve();
  
  // Calculate metrics
  const report = {
    period: `${year}-${String(month).padStart(2, '0')}`,
    total_charges: charges.total,
    total_amount: charges.data.reduce((sum, c) => sum + c.amount, 0),
    successful: charges.data.filter(c => c.paid).length,
    failed: charges.data.filter(c => !c.paid).length,
    balance: balance.available,
    currency: balance.currency
  };
  
  return report;
}

// Generate report
generateMonthlyReport(2024, 1)
  .then(report => console.log(JSON.stringify(report, null, 2)));

# Python - Automated report generation
import omise
from datetime import datetime, timedelta
import json

omise.api_secret = 'skey_test_xxxxx'

def generate_weekly_report():
    """Generate weekly payment report."""
    to_date = datetime.now()
    from_date = to_date - timedelta(days=7)
    
    # Fetch charges
    charges = omise.Charge.list(
        from_date=from_date.isoformat(),
        to_date=to_date.isoformat(),
        limit=100
    )
    
    # Fetch refunds
    refunds = omise.Refund.list(
        from_date=from_date.isoformat(),
        to_date=to_date.isoformat(),
        limit=100
    )
    
    # Calculate metrics
    report = {
        'period': f'{from_date.date()} to {to_date.date()}',
        'charges': {
            'total': len(charges.data),
            'successful': sum(1 for c in charges.data if c.paid),
            'amount': sum(c.amount for c in charges.data if c.paid)
        },
        'refunds': {
            'total': len(refunds.data),
            'amount': sum(r.amount for r in refunds.data)
        }
    }
    
    return report

# Generate and print report
report = generate_weekly_report()
print(json.dumps(report, indent=2))

# Ruby - Daily report automation
require 'omise'
require 'json'
require 'date'

Omise.api_key = 'skey_test_xxxxx'

def generate_daily_report(date = Date.today)
  # Define date range
  from_time = Time.new(date.year, date.month, date.day, 0, 0, 0)
  to_time = Time.new(date.year, date.month, date.day, 23, 59, 59)
  
  # Fetch transactions
  charges = Omise::Charge.list({
    from: from_time.iso8601,
    to: to_time.iso8601,
    limit: 100
  })
  
  # Calculate metrics
  successful_charges = charges.data.select(&:paid)
  failed_charges = charges.data.reject(&:paid)
  
  report = {
    date: date.to_s,
    summary: {
      total_charges: charges.total,
      successful: successful_charges.length,
      failed: failed_charges.length,
      success_rate: (successful_charges.length.to_f / charges.total * 100).round(2),
      total_amount: successful_charges.sum(&:amount),
      average_amount: successful_charges.any? ? 
        (successful_charges.sum(&:amount) / successful_charges.length) : 0
    }
  }
  
  report
end

# Generate report
puts JSON.pretty_generate(generate_daily_report)

<?php
// PHP - Monthly report generation
require_once 'vendor/autoload.php';

define('OMISE_SECRET_KEY', 'skey_test_xxxxx');

function generateMonthlyReport($year, $month) {
    // Calculate date range
    $from = new DateTime("$year-$month-01 00:00:00");
    $to = new DateTime("$year-$month-01 00:00:00");
    $to->modify('last day of this month');
    $to->setTime(23, 59, 59);
    
    // Fetch charges
    $charges = OmiseCharge::retrieve([
        'from' => $from->format(DateTime::ATOM),
        'to' => $to->format(DateTime::ATOM),
        'limit' => 100
    ]);
    
    // Calculate metrics
    $successful = array_filter($charges['data'], function($c) {
        return $c['paid'] === true;
    });
    
    $report = [
        'period' => sprintf('%d-%02d', $year, $month),
        'charges' => [
            'total' => $charges['total'],
            'successful' => count($successful),
            'failed' => $charges['total'] - count($successful),
            'amount' => array_sum(array_column($successful, 'amount'))
        ]
    ];
    
    return $report;
}

// Generate report
$report = generateMonthlyReport(2024, 1);
echo json_encode($report, JSON_PRETTY_PRINT);
?>

// Go - Quarterly report generation
package main

import (
    "encoding/json"
    "fmt"
    "time"
    
    "github.com/omise/omise-go"
    "github.com/omise/omise-go/operations"
)

type QuarterlyReport struct {
    Quarter      string  `json:"quarter"`
    TotalCharges int     `json:"total_charges"`
    Successful   int     `json:"successful"`
    Failed       int     `json:"failed"`
    TotalAmount  int64   `json:"total_amount"`
    SuccessRate  float64 `json:"success_rate"`
}

func generateQuarterlyReport(year int, quarter int) (*QuarterlyReport, error) {
    client, err := omise.NewClient("pkey_test_xxxxx", "skey_test_xxxxx")
    if err != nil {
        return nil, err
    }
    
    // Calculate quarter date range
    startMonth := (quarter-1)*3 + 1
    from := time.Date(year, time.Month(startMonth), 1, 0, 0, 0, 0, time.UTC)
    to := from.AddDate(0, 3, 0).Add(-time.Second)
    
    // Fetch charges
    charges := &omise.ChargeList{}
    err = client.Do(charges, &operations.ListCharges{
        ListParams: operations.ListParams{
            From:  from,
            To:    to,
            Limit: 100,
        },
    })
    if err != nil {
        return nil, err
    }
    
    // Calculate metrics
    successful := 0
    var totalAmount int64
    for _, charge := range charges.Data {
        if charge.Paid {
            successful++
            totalAmount += charge.Amount
        }
    }
    
    report := &QuarterlyReport{
        Quarter:      fmt.Sprintf("Q%d %d", quarter, year),
        TotalCharges: charges.Total,
        Successful:   successful,
        Failed:       charges.Total - successful,
        TotalAmount:  totalAmount,
        SuccessRate:  float64(successful) / float64(charges.Total) * 100,
    }
    
    return report, nil
}

func main() {
    report, err := generateQuarterlyReport(2024, 1)
    if err != nil {
        panic(err)
    }
    
    jsonData, _ := json.MarshalIndent(report, "", "  ")
    fmt.Println(string(jsonData))
}

Best Practices

Reporting Efficiency

Use Appropriate Date Ranges
- Query only the data you need
- Use pagination for large datasets
- Cache frequently accessed reports
Optimize API Calls
- Batch requests when possible
- Use webhooks instead of polling
- Implement rate limiting handling
Data Export Strategy
- Export during off-peak hours
- Use appropriate file formats
- Compress large exports
Schedule Reports
- Automate recurring reports
- Set up email notifications
- Store reports in cloud storage

Security Best Practices

Access Control
- Use role-based permissions
- Regularly audit user access
- Revoke unused API keys
- Enable two-factor authentication
Data Protection
- Encrypt exported data
- Use secure file transfer
- Implement data retention policies
- Mask sensitive information
Compliance
- Follow PCI DSS requirements
- Comply with GDPR/local regulations
- Maintain audit trails
- Document data handling procedures

Troubleshooting

Common Issues

Report Not Loading

Symptoms: Dashboard shows loading indicator indefinitely

Solutions:

Check internet connection
Clear browser cache and cookies
Try a different browser
Verify date range is not too large
Check if account has necessary permissions

Missing Data

Symptoms: Expected transactions not appearing in reports

Solutions:

Verify correct date range selected
Check timezone settings
Confirm filters are not excluding data
Ensure transactions are in correct status
Wait for data synchronization (up to 5 minutes)

Export Failures

Symptoms: Export button doesn't respond or downloads fail

Solutions:

Reduce date range for large exports
Try different export format
Check browser pop-up blocker settings
Verify sufficient disk space
Use API for very large exports

API Access Issues

Symptoms: 401 or 403 errors when accessing reports via API

Solutions:

// Node.js - Debug API access issues
const omise = require('omise')({
  secretKey: 'skey_test_xxxxx'
});

// Test API authentication
omise.account.retrieve()
  .then(account => {
    console.log('✓ Authentication successful');
    console.log('Account:', account.email);
  })
  .catch(err => {
    console.error('✗ Authentication failed');
    console.error('Error:', err.message);
    console.error('Code:', err.code);
    
    // Common solutions
    if (err.code === 'authentication_failure') {
      console.log('→ Check API key is correct');
      console.log('→ Verify using secret key (not public key)');
    }
    if (err.code === 'invalid_account') {
      console.log('→ Account may be inactive');
      console.log('→ Contact support');
    }
  });

Timezone Discrepancies

Symptoms: Report timestamps don't match expected values

Solutions:

Verify timezone setting in account preferences
Check browser timezone matches account timezone
Use UTC for cross-timezone reporting
Specify timezone explicitly in API calls

FAQ

General Questions

Q1: How far back can I access historical data?

A: Omise retains transaction data for up to 7 years. You can access all data from your account creation date. For data older than 1 year, we recommend using API access with pagination for large queries.

Q2: Can I schedule automatic report generation?

A: Yes, you can schedule reports in the Dashboard:

Navigate to Reports > Scheduled Reports
Click "Create Schedule"
Select report type, frequency, and recipients
Reports are delivered via email with download links

Q3: What's the difference between transaction time and settlement time?

A: Transaction time is when a payment is processed. Settlement time is when funds are transferred to your bank account (typically T+3 to T+7 business days depending on your merchant agreement).

Q4: Can I customize the columns shown in reports?

A: Yes, click the column selector icon (☰) in the report header to show/hide columns. Your preferences are saved per report type. API users can specify fields using the fields parameter.

Q5: How do I handle reports for multiple currencies?

A: Reports show amounts in the original transaction currency. You can:

Filter by specific currency
View multi-currency summary reports
Export with currency conversion (based on transaction-day rates)
Use the API to apply custom conversion rates

Q6: Are reports available in test mode?

A: Yes, reports are available in both test and live modes. Toggle between modes using the mode selector in the top navigation. Test mode reports use test transactions and don't affect live data.

Q7: How often is report data updated?

A: Dashboard reports are updated in near real-time:

Transaction data: Updates within 1-2 minutes
Balance data: Updates within 5 minutes
Settlement data: Updates after settlement processing
Analytics: Updates every 15 minutes

Q8: Can I share reports with external accountants?

A: Yes, you can:

Export reports and share files securely
Create a limited-access account for your accountant
Use scheduled reports with external email addresses
Generate shareable report links (valid for 7 days)

Documentation

Transaction Reports - Detailed transaction reporting
Balance Reports - Balance and settlement reports
API Reference - Programmatic report access
Dashboard Guide - Complete dashboard documentation

Tools

Report API Playground - Test report queries
Export Template Generator - Create custom export formats
Report Scheduler - Automate report delivery

Support

Knowledge Base - Common reporting questions
API Status - Service availability
Contact Support - Get help from our team

Next Steps

Explore Specific Reports

Transaction Reports
- Payment and charge reports
- Refund reports
- Transaction search and filtering
Balance Reports
- Balance history
- Settlement and payout reports
- Fee breakdowns
Analytics Dashboard
- Advanced analytics
- Performance metrics
- Business intelligence

Set Up Automation

Schedule Regular Reports
- Daily transaction summaries
- Weekly revenue reports
- Monthly accounting reports
Configure API Access
- Create read-only API keys
- Build custom reporting tools
- Integrate with accounting software
Enable Notifications
- Set up email alerts
- Configure webhook endpoints
- Monitor key metrics

Overview​

Dashboard Navigation​

Accessing Reports​

Dashboard Layout​

Available Reports​

Standard Reports​

1. Transaction Reports​

2. Balance Reports​

3. Performance Reports​

4. Customer Reports​

Date Filtering​

Standard Date Ranges​

Custom Date Ranges​

Date Filter Examples​

Timezone Handling​

Dashboard Timezone Settings​

API Timezone Configuration​

Dashboard Permissions​

User Roles​

1. Administrator​

2. Manager​

3. Analyst​

4. Support​

5. Accountant​

Permission Configuration​

API Access Control​

Programmatic Report Access​

API Overview​

Best Practices​

Reporting Efficiency​

Security Best Practices​

Troubleshooting​

Common Issues​

Report Not Loading​

Missing Data​

Export Failures​

API Access Issues​

Timezone Discrepancies​

FAQ​

General Questions​

Related Resources​

Documentation​

Tools​

Support​

Next Steps​

Explore Specific Reports​

Set Up Automation​

Overview

Dashboard Navigation

Accessing Reports

Dashboard Layout

Available Reports

Standard Reports

1. Transaction Reports

2. Balance Reports

3. Performance Reports

4. Customer Reports

Date Filtering

Standard Date Ranges

Custom Date Ranges

Date Filter Examples

Timezone Handling

Dashboard Timezone Settings

API Timezone Configuration

Dashboard Permissions

User Roles

1. Administrator

2. Manager

3. Analyst

4. Support

5. Accountant

Permission Configuration

API Access Control

Programmatic Report Access

API Overview

Best Practices

Reporting Efficiency

Security Best Practices

Troubleshooting

Common Issues

Report Not Loading

Missing Data

Export Failures

API Access Issues

Timezone Discrepancies

FAQ

General Questions

Related Resources

Documentation

Tools

Support

Next Steps

Explore Specific Reports

Set Up Automation