Data Import and Migration Tools

Light imports data from spreadsheets, CSV files, and other systems, whether you are setting up a new company or migrating from another accounting system.

# What is this page about

This page covers what you can import into Light, how to prepare your files, where each import lives in the product, and how to check, correct, and undo an import once it has run. Use it when you are setting up a new company or bringing history across from another system.

On this page

• Import capabilities
• Preparing import files
• Accessing import tools
• Importing chart of accounts
• Customers
• Importing vendor master
• Importing historical transactions
• Importing journal entries
• Opening balance import
• Data validation
• Reviewing before completion
• Handling import errors
• Multi-currency import
• Import history
• Undoing an import
• Best practices for importing
• Related articles

# Import capabilities

Light supports importing:

• Chart of accounts: GL accounts and account structure
• Vendor master: Vendor information (customers are created individually or via the API)
• Historical transactions: past sales invoices, bills, credit notes, and customer credits, each through its own CSV import
• Journal entries: bulk journal entries, including opening balances
• Budgets: budget data for planning, through a separate scenario upload rather than the import framework used by the rest

Good to know: To enter fixed assets, create a journal entry, bill, or sales invoice with a Fixed Asset release template applied on one or more lines. The fixed asset register lives at Accounting → Releases, where you filter by Fixed asset type to see only fixed assets. See Configuring releases: depreciation, prepayments, deferred revenue for details.

# Preparing import files

Prepare your data as a CSV file. Every import uses CSV (.csv), including chart of accounts, journal entries, vendors, transactions, and budgets.

File requirements:

• The first row holds your column headers, such as Account Code, Account Name, and Balance
• Data types match the field, so numbers stay numeric and dates stay dates
• Column headers use plain text
• Light detects UTF-8 encoding on its own, so international characters come through intact

Start from Light's import template rather than a blank file.

# Accessing import tools

Each import lives on the page for the records it creates, rather than a single central import screen:

• Chart of accounts: Settings (gear icon) → Chart of accounts
• Vendors: Business partners → Vendors
• Journal entries: Accounting → Journal entries
• Historical transactions (sales invoices, bills, credit notes, customer credits): the corresponding page for each document type

The general flow is the same everywhere:

1. Open the page for the record type you want to import
2. Open the upload/import action
3. Download the import template (shows required and optional fields)
4. Fill the template with your data
5. Upload the file
6. Light validates the file and reports any errors
7. Review the imported records

# Importing chart of accounts

Create your GL account structure:

1. Download COA template

2. Fill in:

   • Account code (required): unique identifier, such as 1000, 1100, or 1110
   • Account name (required): descriptive name, such as Cash or Accounts Receivable
   • Account category (required): Standard, Sum, or Header, each described below
   • Entity codes (required): which company entities the account belongs to
   • Status (required): the account's status
   • Account type: specific type such as Bank, Accounts receivable, or Cost of sales, grouped under the Asset, Liability, Equity, Revenue, and Expense classifications
   • Currency (optional): the account's currency
   • Aggregation rule: for Sum accounts only, defining which accounts roll up

3. Upload file (CSV)

4. Light validates the file and lets you review and fix lines before completing

5. Light creates GL accounts

6. You can now post transactions

# Account categories

Light supports three account categories:

• Standard: Regular posting accounts where transactions are recorded
• Sum: Roll-up accounts that aggregate balances from other accounts for reporting (no direct posting)
• Header: Visual grouping labels that appear on reports with zero balance (no direct posting)

# Aggregation rules for Sum accounts

Sum accounts use an aggregation rule to define which accounts roll up into them. The rule specifies account code ranges in the format start:end, with multiple ranges separated by commas.

For example, if you have expense accounts 60000 to 60999 for Operations and 62000 to 62999 for Administration, you could create a Sum account with the aggregation rule 60000:60999,62000:62999 to show the combined total on reports.

Good to know: Use consistent numbering for account codes (e.g., 1000s = assets, 2000s = liabilities). This makes defining aggregation rules straightforward, since you can group accounts by code range.

# Customers

Create customers one at a time at Business partners → Customers with + Create customer, or create them programmatically through the API. See API access and custom integrations.

# Importing vendor master

Load vendor information:

1. Download the vendor upload template from Business partners → Vendors

2. Fill in the columns you need, including:

   • Name: Full company name
   • Description: Free-text description
   • Email, Phone, Website
   • Country, City, Address, Zipcode
   • VAT ID: Vendor tax/VAT number
   • Bank details: Bank name, country, account number, BIC, domestic account number/code, Swedish Bankgiro/Plusgiro, recipient name
   • Currency: Default currency
   • Entity codes and Default entity code: Which company entities the vendor belongs to
   • Ledger account code: Default expense account
   • Tax code: Default tax code

3. Upload the file. Light maps your file's columns to these fields, and you can review the mapping

4. Light validates each line and reports the lines with errors so you can fix them

5. Light creates vendor records

6. Your vendors are ready for AP invoicing

# Importing historical transactions

Migrate past transactions from your old system. Each document type has its own CSV import with its own template:

• Sales invoices (AR)
• Bills (AP)
• Credit notes
• Customer credits

For each import:

1. Download the CSV template for that document type. Required columns carry a (required) annotation
2. Fill in the transaction data (dates, amounts, currency, business partner, account codes, tax codes, line items)
3. Upload the file. Light processes the import as a background job
4. Light validates each entry and collects failed entries in a downloadable error report
5. Choose whether imported documents are posted immediately or left for review
6. Journal entries are imported separately through the journal entry CSV upload, described below

Important: Migrate current-year transactions and open receivables and payables. Bring prior years across as opening balances instead.

# Importing journal entries

Upload journal entries via CSV with the following format.

# Downloading the template

Click Download template to get a company-specific CSV template that includes:

• All required columns with (required) annotations
• Your company's active custom properties with (custom) annotations
• Only custom properties relevant to journal entries

The template dynamically reflects your company's configuration, so you can fill it in and upload directly.

# Required columns

# Optional columns

# Using display names

You can use friendly display names instead of internal system names:

• Custom property columns: Use the label name (e.g., "Cost Center") instead of the internal name (e.g., "cost_center")
• Custom property values: Use value labels (e.g., "New York") instead of internal names (e.g., "new_york") for single-select and multi-select fields
• Accrual templates: Use the template name instead of the UUID

How each column resolves differs by type: accounts, taxes and entities match by code; release templates match by UUID first, then by template name; custom property values match by internal name first, then by label. Existing uploads that use internal names keep working.

# Multi-select values

For multi-select custom properties, separate values with semicolons:

New York; Los Angeles; Chicago

This format works even when labels contain spaces.

# Business partner fields

• business partner name: required, a text field
• business partner id: the UUID of an existing customer or vendor in Light. Identify the business partner by either name or UUID, and keep whichever you use accurate and consistent, since ambiguous or mismatched names cause errors.

Good to know: Use entry id to group multiple lines into a single journal entry. All lines with the same entry id will be combined into one balanced entry. Headers with (required) and (custom) annotations from the template are automatically stripped during import.

# Archiving an import

If you need to remove an import from your books (for example, to correct errors or undo a test import), archive it from the import history table:

1. Go to Accounting → Journal entries and open the journal entry import history
2. Find the import you want to archive
3. Click the actions menu (⋯) and select Archive
4. If the import created journal entries, confirm the action

When you archive an import:

• Draft entries are permanently removed from the system
• Posted entries are reversed with offsetting journal entries, preserving the audit trail

Important: Archiving requires company admin or controller permissions. Entries in closed periods, entries that are bank-reconciled, and entries pending approval can fail to archive. When that happens the import status shows Archive failed, and Light support can resolve it.

# Opening balance import

Opening balances are imported as a journal entry using the journal entry CSV upload described above:

1. Prepare a CSV where all lines share the same entry id, dated as of your transition date
2. Enter each GL account's opening balance as a debit or credit line against its account code
3. Ensure total debits equal total credits
4. Upload the file
5. Light creates the opening balance journal entry, which you can review before posting

# Data validation

Light checks every import line by line before creating records. Those checks catch problems such as:

• Missing required fields, or values in the wrong data type
• Account, customer, or vendor codes that do not exist in Light
• Amounts that are not numeric, or entries where debits and credits fail to balance
• Related values that contradict each other

Light recognises a repeated upload of the same file and skips re-processing it, so uploading twice creates one set of records.

When a line fails, Light produces an error report showing exactly what to fix.

# Reviewing before completion

Chart of accounts and vendor imports include a mapping and review step:

1. After you upload the file, Light maps your file's columns to Light fields
2. Review that the mapping is correct (columns mapped to right fields)
3. Review the imported lines and fix any lines with validation errors
4. Complete the import

The mapping and review steps let you correct the file before Light creates any records.

# Handling import errors

When a line fails validation:

1. Light records an error for each failed entry

2. Download the error report, which shows:

   • The entry that failed
   • The error message (missing value, invalid value, unbalanced entry, and so on)

3. Fix the issue in your file

4. Re-upload

5. The import completes once validation passes

# Multi-currency import

When importing with multiple currencies:

1. Include the currency column in the template
2. Specify the currency code (USD, EUR, GBP) for each transaction
3. Light converts to your GL currency using the rate from the transaction date. Supplying the rate columns in your CSV overrides that lookup
4. Light records all amounts in your GL

# Import history

Light keeps a history of each import:

• File name
• Import status
• User who triggered the import
• Date and time of import
• Error count, with a downloadable error report

Each import type (journal entries, vendors, chart of accounts, transactions) has its own import history on its page.

# Import statuses

Status labels differ by import type.

Journal entry and historical transaction imports show a status in the history table:

• Syncing… while the file uploads and processes. Journal entry imports show this as Synching…
• Complete once the import finishes. Individual lines that failed appear as an error count with an error report link, and the status stays Complete
• Corrupt file when Light could not process the file
• Archiving…, then Archived, when you archive an import
• Archive failed when archiving cannot complete

Chart of accounts and vendor imports run as a step-by-step wizard rather than a status table. They show Processing… while the import runs, and Processing paused when it stops for errors, with the message "Please resolve the following errors before resuming". Processing paused appears whether some lines succeeded or none did, so check the listed errors to see which.

# Undoing an import

If an import creates bad data, you can undo it from the import history:

1. Find the import in the import history
2. Delete (or archive, for journal entry imports) the import
3. Light removes the documents created by the import. Draft documents are deleted, and posted documents are reversed to preserve the audit trail
4. Fix the import file and re-import

The undo runs as a background job; the import status shows whether it succeeded or failed.

# Best practices for importing

Test first: Test imports with sample data before importing the full dataset.

Validate data: Check your source data before importing, with required fields populated and duplicates removed.

Plan mapping: Work out which source fields map to which Light fields.

Schedule off-peak: Import during quiet periods so other users keep full performance.

Monitor closely: After the import, review the results and verify accuracy before you treat it as complete.

# Related articles

• Integrations overview
• Data migration from E-Conomic
• Data migration from QuickBooks
• Cutover fundamentals and execution
• API access and custom integrations