Front Accounting APIs SDKs & Libraries: Integration Guide (2026)

SDKs overview

Front Accounting is an open-source enterprise resource planning (ERP) system designed for small to medium-sized businesses. Unlike many modern API providers that offer dedicated software development kits (SDKs) for various programming languages, Front Accounting's architecture emphasizes direct interaction with its PHP codebase and MySQL database for integration purposes. This approach means that formal, vendor-supported SDKs in the traditional sense are not a primary component of its integration strategy.

Developers seeking to integrate with Front Accounting typically engage with the system by either directly manipulating its MySQL database, extending its core PHP functionalities, or building custom client libraries that interact with the system's web interface or custom-developed endpoints. The project's Front Accounting Wiki serves as the primary resource for understanding its internal structure and potential integration points.

The absence of official, language-specific SDKs necessitates a different development approach, often involving a deeper understanding of web development principles, database management, and the PHP programming language itself. This can provide a high degree of flexibility for customization but requires more foundational work from integrators.

Official SDKs by language

As of 2026, Front Accounting does not provide official, vendor-supported SDKs for specific programming languages in the manner that many modern API services do. The project's open-source nature and architecture mean that integration is primarily achieved through direct database access, modification of the PHP source code, or by developing custom interfaces that interact with the application's existing web-based functionalities. This model differs from typical REST API integrations where SDKs abstract away HTTP requests and response parsing.

The table below reflects the current status regarding official SDKs:

The implied "SDK" for Front Accounting is its own PHP source code, which developers can extend or modify to suit specific integration needs. This requires developers to be proficient in PHP programming concepts and familiar with the Front Accounting application's internal structure.

Installation

Given the absence of official, dedicated SDKs, "installation" for Front Accounting APIs typically refers to setting up the Front Accounting application itself, or installing general-purpose libraries that can facilitate interaction with its underlying database or web interface.

Front Accounting Application Installation

To begin any integration work, Front Accounting must be installed on a web server environment. The general steps are:

1. Download: Obtain the latest stable version of Front Accounting from the Front Accounting homepage.
2. Server Setup: Ensure you have a web server (e.g., Apache or Nginx) with PHP (version 7.4 or higher recommended) and a MySQL/MariaDB database server installed.
3. Database Creation: Create a new database and a user with appropriate permissions for Front Accounting.
4. File Placement: Unzip the downloaded Front Accounting files into your web server's document root.
5. Web Installer: Navigate to the Front Accounting directory in your web browser and follow the on-screen installation wizard to configure database connections and initial settings.

Detailed installation instructions are available on the Front Accounting Wiki installation guide.

General-Purpose Library Installation for Custom Clients

For developing custom clients in other languages, you will install standard libraries relevant to your chosen language for database connectivity or HTTP requests. Examples include:

• PHP (for custom modules): No additional installation beyond Front Accounting itself, unless specific PHP extensions are needed (e.g., php-mysql).
• Python: For database interaction, use pip install mysql-connector-python. For web interaction (e.g., if you build a custom REST endpoint within Front Accounting), use pip install requests.
• Node.js: For database interaction, use npm install mysql2. For web interaction, use npm install axios.

These libraries are not specific to Front Accounting but are fundamental tools for interacting with PHP applications and MySQL databases.

Quickstart example

A "quickstart example" for Front Accounting APIs typically involves demonstrating how to interact with its underlying data or extend its functionality. Since there are no official SDKs, this example focuses on a common integration pattern: direct database interaction using PHP, which is the native language of Front Accounting.

Example: Retrieving a list of customers via direct database query (PHP)

This example assumes Front Accounting is installed and configured, and you have direct access to its database credentials. This code would typically run within a custom PHP script or a Front Accounting extension.

<?php

// --- Configuration (replace with your actual database details) ---
$servername = "localhost";
$username = "fa_user"; // Your Front Accounting database username
$password = "fa_password"; // Your Front Accounting database password
$dbname = "frontaccounting"; // Your Front Accounting database name

// Create connection
$conn = new mysqli($servername, $username, $password, $dbname);

// Check connection
if ($conn->connect_error) {
    die("Connection failed: " . $conn->connect_error);
}

// SQL query to fetch customer data
// Note: Table names in Front Accounting typically have a prefix (e.g., '0_customers')
// You might need to adjust '0_customers' based on your FA configuration.
$sql = "SELECT customer_id, cust_name, address FROM 0_customers LIMIT 10";
$result = $conn->query($sql);

if ($result->num_rows > 0) {
    echo "<h2>Front Accounting Customers</h2>";
    echo "<table border='1'>";
    echo "<tr><th>ID</th><th>Name</th><th>Address</th></tr>";
    // Output data of each row
    while($row = $result->fetch_assoc()) {
        echo "<tr>";
        echo "<td>" . htmlspecialchars($row["customer_id"]) . "</td>";
        echo "<td>" . htmlspecialchars($row["cust_name"]) . "</td>";
        echo "<td>" . htmlspecialchars($row["address"]) . "</td>";
        echo "</tr>";
    }
    echo "</table>";
} else {
    echo "0 results";
}

$conn->close();

?>

Explanation:

1. Database Connection: Establishes a connection to the MySQL database where Front Accounting stores its data using PHP's mysqli extension.
2. SQL Query: Executes a standard SQL SELECT statement to retrieve customer IDs, names, and addresses from the 0_customers table. Note that Front Accounting tables are often prefixed with 0_ (or another number based on multi-company setup).
3. Result Processing: Iterates through the returned rows and displays the customer information.
4. Error Handling: Includes basic error checking for the database connection.

This approach highlights the need for direct database schema knowledge, which can be found by inspecting the Front Accounting database or its source code. For more complex interactions, developers might build custom PHP endpoints within Front Accounting itself, following the HTTP methods for creating, reading, updating, and deleting resources.

Community libraries

Due to Front Accounting's architecture, community efforts tend to focus on extensions, modifications, and custom integrations rather than standalone, language-specific SDKs. The primary "community" around Front Accounting revolves around its forums and the shared knowledge of its PHP codebase.

• Front Accounting Extensions: The Front Accounting Modules & Extensions page lists various community-contributed modules that extend core functionality. These are typically written in PHP and integrate directly into the Front Accounting application. Examples include payment gateway integrations, shipping modules, and reporting enhancements.
• Custom Integrations: Many users develop custom scripts or small applications in various languages (Python, Node.js, Ruby, etc.) to interact with Front Accounting. These often involve:
  • Direct Database Access: Using standard database connector libraries (e.g., Python's mysql-connector-python or Node.js's mysql2) to read from and write to Front Accounting's MySQL database.
  • Web Scraping/Automation: In some cases, developers might use libraries like Python's BeautifulSoup or Node.js's Puppeteer to automate interactions with Front Accounting's web interface, though this is generally less robust than direct database or API interaction.
  • Custom API Endpoints: Advanced users might develop their own PHP-based RESTful API endpoints within the Front Accounting framework to expose specific data or functionality to external applications. This requires significant knowledge of the Front Accounting codebase and web standards for URIs.

When considering community libraries or integrations, it is crucial to verify their maintenance status, compatibility with your Front Accounting version, and security practices, as they are not officially supported by the core Front Accounting project.