Acumatica Intercompany Transactions

Introduction

Intercompany transactions in Acumatica enable organizations with multiple legal entities to record and reconcile transactions between subsidiaries. This is essential for accurate consolidated financial reporting.

Multi-Entity Setup

POST /api/data/CR102000
Content-Type: application/json

{
  "CompanyID": { "value": "SUB001" },
  "CompanyName": { "value": "Subsidiary Company" },
  "TaxID": { "value": "12-3456789" },
  "BaseCurrency": { "value": "USD" },
  "Consolidated": { "value": true }
}

Transaction Processing

async function createIntercompanyTransfer(fromEntity, toEntity, amount, items) {
    // Create intercompany AR invoice in source
    const invoiceData = {
        CustomerID: { value: `IC-${toEntity}` },
        Details: items.map(item => ({
            InventoryID: { value: item.sku },
            Qty: { value: item.qty },
            UnitPrice: { value: item.price }
        }))
    };

    await createInvoice(baseUrl, token, fromEntity, 'AR301000', invoiceData);
}

Eliminations

async function generateEliminationEntries(period) {
    const intercompanyBalances = await getIntercompanyBalances(period);
    
    for (const balance of intercompanyBalances) {
        const eliminationEntry = {
            GLAccount: { value: balance.eliminationAccount },
            Amount: { value: -balance.balance },
            Description: { value: `Eliminate IC - ${balance.entity}` }
        };

        await createGLEntry(baseUrl, token, period, eliminationEntry);
    }
}

Transfer Pricing

async function applyTransferPricingRules(fromEntity, toEntity, product, qty) {
    const basePrice = await getBasePrice(product);
    
    const rules = await getTransferPricingRules(product);
    
    let transferPrice = basePrice;
    
    if (rules.method === 'percentage') {
        transferPrice = basePrice * (1 + rules.percentage / 100);
    } else if (rules.method === 'fixed') {
        transferPrice = rules.fixedPrice;
    }
    
    return transferPrice;
}

Complete Integration

class IntercompanyManager {
    async processTransaction(transaction) {
        await this.validateEntities(transaction.from, transaction.to);
        
        const transferPrice = await this.calculateTransferPrice(transaction);
        
        await this.createIntercompanyInvoice(transaction.from, transaction.to, transferPrice);
        
        await this.createIntercompanyBill(transaction.to, transaction.from, transferPrice);
        
        await this.reconcile(transaction);
    }

    async generateConsolidatedReport(period) {
        await this.eliminateIntercompanyBalances(period);
        
        return await this.generateConsolidatedFinancials(period);
    }
}

Summary

Managing intercompany transactions in Acumatica enables accurate accounting across multiple entities. With proper setup, elimination entries, and transfer pricing rules, you can maintain accurate consolidated financial statements.

For more information, check out our other tutorials on Consolidation Reporting and Audit Trails.