Getting Started

// JavaScript/Node.js with axios
const axios = require('axios');

const client = axios.create({
  baseURL: 'https://api.bigledger.com/v1',
  headers: {
    'Authorization': 'Bearer blg_live_sk_1234567890abcdef',
    'Content-Type': 'application/json',
    'X-Company-Id': 'company_abc123'
  }
});

async function createCustomer() {
  try {
    const response = await client.post('/customers', {
      name: 'Test Customer',
      email: 'test@example.com',
      phone: '+60123456789'
    });
    
    console.log('Customer created:', response.data);
    return response.data;
  } catch (error) {
    console.error('Error:', error.response?.data || error.message);
  }
}

async function createInvoice(customerId) {
  try {
    const response = await client.post('/invoices', {
      customerId: customerId,
      invoiceDate: new Date().toISOString().split('T')[0],
      dueDate: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString().split('T')[0],
      items: [
        {
          description: 'Professional Services',
          quantity: 10,
          unitPrice: 100.00,
          taxCode: 'SST',
          taxRate: 6.0
        }
      ]
    });
    
    console.log('Invoice created:', response.data);
    return response.data;
  } catch (error) {
    console.error('Error:', error.response?.data || error.message);
  }
}

// Usage
(async () => {
  const customer = await createCustomer();
  if (customer) {
    await createInvoice(customer.data.id);
  }
})();

# Python with requests
import requests
import json
from datetime import datetime, timedelta

headers = {
    'Authorization': 'Bearer blg_live_sk_1234567890abcdef',
    'Content-Type': 'application/json',
    'X-Company-Id': 'company_abc123'
}

base_url = 'https://api.bigledger.com/v1'

def create_customer():
    url = f'{base_url}/customers'
    data = {
        'name': 'Test Customer',
        'email': 'test@example.com',
        'phone': '+60123456789'
    }
    
    response = requests.post(url, headers=headers, json=data)
    
    if response.status_code == 201:
        print('Customer created:', response.json())
        return response.json()
    else:
        print('Error:', response.json())
        return None

def create_invoice(customer_id):
    url = f'{base_url}/invoices'
    today = datetime.now().strftime('%Y-%m-%d')
    due_date = (datetime.now() + timedelta(days=30)).strftime('%Y-%m-%d')
    
    data = {
        'customerId': customer_id,
        'invoiceDate': today,
        'dueDate': due_date,
        'items': [
            {
                'description': 'Professional Services',
                'quantity': 10,
                'unitPrice': 100.00,
                'taxCode': 'SST',
                'taxRate': 6.0
            }
        ]
    }
    
    response = requests.post(url, headers=headers, json=data)
    
    if response.status_code == 201:
        print('Invoice created:', response.json())
        return response.json()
    else:
        print('Error:', response.json())
        return None

# Usage
customer = create_customer()
if customer:
    create_invoice(customer['data']['id'])

<?php
// PHP with cURL

class BigLedgerClient {
    private $baseUrl = 'https://api.bigledger.com/v1';
    private $headers;
    
    public function __construct($apiKey, $companyId) {
        $this->headers = [
            'Authorization: Bearer ' . $apiKey,
            'Content-Type: application/json',
            'X-Company-Id: ' . $companyId
        ];
    }
    
    private function makeRequest($method, $endpoint, $data = null) {
        $ch = curl_init();
        
        curl_setopt_array($ch, [
            CURLOPT_URL => $this->baseUrl . $endpoint,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => $this->headers,
            CURLOPT_CUSTOMREQUEST => $method,
        ]);
        
        if ($data) {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        }
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);
        
        return [
            'status' => $httpCode,
            'data' => json_decode($response, true)
        ];
    }
    
    public function createCustomer($customerData) {
        return $this->makeRequest('POST', '/customers', $customerData);
    }
    
    public function createInvoice($invoiceData) {
        return $this->makeRequest('POST', '/invoices', $invoiceData);
    }
}

// Usage
$client = new BigLedgerClient(
    'blg_live_sk_1234567890abcdef',
    'company_abc123'
);

$customerData = [
    'name' => 'Test Customer',
    'email' => 'test@example.com',
    'phone' => '+60123456789'
];

$customer = $client->createCustomer($customerData);

if ($customer['status'] === 201) {
    echo "Customer created: " . json_encode($customer['data']) . "\n";
    
    $invoiceData = [
        'customerId' => $customer['data']['data']['id'],
        'invoiceDate' => date('Y-m-d'),
        'dueDate' => date('Y-m-d', strtotime('+30 days')),
        'items' => [
            [
                'description' => 'Professional Services',
                'quantity' => 10,
                'unitPrice' => 100.00,
                'taxCode' => 'SST',
                'taxRate' => 6.0
            ]
        ]
    ];
    
    $invoice = $client->createInvoice($invoiceData);
    echo "Invoice created: " . json_encode($invoice['data']) . "\n";
}
?>

// Java with OkHttp
import okhttp3.*;
import com.google.gson.Gson;
import java.io.IOException;
import java.time.LocalDate;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.Arrays;

public class BigLedgerClient {
    private static final String BASE_URL = "https://api.bigledger.com/v1";
    private final OkHttpClient client;
    private final String apiKey;
    private final String companyId;
    private final Gson gson;
    
    public BigLedgerClient(String apiKey, String companyId) {
        this.client = new OkHttpClient();
        this.apiKey = apiKey;
        this.companyId = companyId;
        this.gson = new Gson();
    }
    
    private Response makeRequest(String method, String endpoint, Object data) throws IOException {
        Request.Builder requestBuilder = new Request.Builder()
            .url(BASE_URL + endpoint)
            .addHeader("Authorization", "Bearer " + apiKey)
            .addHeader("Content-Type", "application/json")
            .addHeader("X-Company-Id", companyId);
            
        if (data != null) {
            RequestBody body = RequestBody.create(
                gson.toJson(data),
                MediaType.get("application/json")
            );
            requestBuilder.method(method, body);
        } else {
            requestBuilder.method(method, null);
        }
        
        return client.newCall(requestBuilder.build()).execute();
    }
    
    public void createCustomerAndInvoice() throws IOException {
        // Create customer
        Map<String, Object> customerData = new HashMap<>();
        customerData.put("name", "Test Customer");
        customerData.put("email", "test@example.com");
        customerData.put("phone", "+60123456789");
        
        Response customerResponse = makeRequest("POST", "/customers", customerData);
        if (customerResponse.isSuccessful()) {
            System.out.println("Customer created: " + customerResponse.body().string());
            
            // Create invoice
            Map<String, Object> item = new HashMap<>();
            item.put("description", "Professional Services");
            item.put("quantity", 10);
            item.put("unitPrice", 100.00);
            item.put("taxCode", "SST");
            item.put("taxRate", 6.0);
            
            Map<String, Object> invoiceData = new HashMap<>();
            invoiceData.put("customerId", "cust_789xyz123"); // Use actual customer ID
            invoiceData.put("invoiceDate", LocalDate.now().toString());
            invoiceData.put("dueDate", LocalDate.now().plusDays(30).toString());
            invoiceData.put("items", Arrays.asList(item));
            
            Response invoiceResponse = makeRequest("POST", "/invoices", invoiceData);
            if (invoiceResponse.isSuccessful()) {
                System.out.println("Invoice created: " + invoiceResponse.body().string());
            }
        }
    }
    
    public static void main(String[] args) {
        try {
            BigLedgerClient client = new BigLedgerClient(
                "blg_live_sk_1234567890abcdef",
                "company_abc123"
            );
            client.createCustomerAndInvoice();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

npm install @bigledger/sdk

pip install bigledger-sdk

composer require bigledger/sdk

import { BigLedgerClient } from '@bigledger/sdk';

const client = new BigLedgerClient({
  apiKey: 'blg_live_sk_1234567890abcdef',
  companyId: 'company_abc123'
});

// Create customer
const customer = await client.customers.create({
  name: 'Test Customer',
  email: 'test@example.com'
});

// Create invoice
const invoice = await client.invoices.create({
  customerId: customer.id,
  items: [
    {
      description: 'Professional Services',
      quantity: 10,
      unitPrice: 100.00
    }
  ]
});

from bigledger import BigLedgerClient

client = BigLedgerClient(
    api_key='blg_live_sk_1234567890abcdef',
    company_id='company_abc123'
)

# Create customer
customer = client.customers.create({
    'name': 'Test Customer',
    'email': 'test@example.com'
})

# Create invoice
invoice = client.invoices.create({
    'customer_id': customer['id'],
    'items': [
        {
            'description': 'Professional Services',
            'quantity': 10,
            'unit_price': 100.00
        }
    ]
})

use BigLedger\BigLedgerClient;

$client = new BigLedgerClient([
    'api_key' => 'blg_live_sk_1234567890abcdef',
    'company_id' => 'company_abc123'
]);

// Create customer
$customer = $client->customers->create([
    'name' => 'Test Customer',
    'email' => 'test@example.com'
]);

// Create invoice
$invoice = $client->invoices->create([
    'customerId' => $customer['id'],
    'items' => [
        [
            'description' => 'Professional Services',
            'quantity' => 10,
            'unitPrice' => 100.00
        ]
    ]
]);