How to Set Up Python QuickBooks Integration: Easy Step-by-Step Explanation

Want to automate QuickBooks data extraction with Python?

Doing so can streamline financial reporting, enable advanced data transformations, and eliminate manual exports.

Python’s robust libraries, combined with QuickBooks’ API, allow you to access, structure, and analyze financial data programmatically. The approach enables feeding QuickBooks data into analytics pipelines, dashboards, or custom automation workflows.

Below, we cover three methods to set up Python–QuickBooks integration, ranging from managed platforms to fully customizable, open-source workflows

Prerequisites for Python QuickBooks Integration

Before setting up Python–QuickBooks integration, ensure you have:

• QuickBooks Online account with API access (Sandbox or Production)
• QuickBooks OAuth 2.0 credentials: Client ID, Client Secret, Refresh Token, Realm ID
• Python 3.x installed with pip
• Internet access to call QuickBooks APIs
• Clear scope of data to be synced (Invoices, Customers, Payments, etc.)
• Secure storage for API credentials (environment variables or secrets manager)
  

Additional requirements

• Hevo method: Active Hevo account with QuickBooks connector and destination configured.
• Direct Python API method: Working knowledge of REST APIs, OAuth 2.0, pagination, and rate limits.
• Singer (open-source ETL) method: virtualenv for dependency isolation, Git for installing taps and targets, Singer tools (tap-quickbooks, target-csv, singer-python), and command-line access.

How to Set up Python QuickBooks Integration?

Python–QuickBooks integration can be implemented using the following three approaches:

• Using Hevo’s No-Code Data Integration Platform
• Direct QuickBooks API Integration Using Python
• Using Open-Source ETL Frameworks with Python (Singer)

Method	Use case	Advantage	Limitation
Hevo No-Code Platform	Automated, scalable QuickBooks data ingestion for analytics	Managed syncs, auto schema handling	Tool cost compared to DIY
Python QuickBooks API	Custom data extraction and domain-specific automation	Full implementation control	High maintenance effort
Singer + Python	Cost-effective batch extraction with standardized ETL patterns	Standardized, extensible framework	Set up and monitoring overhead

Method 1: Using Hevo’s No-Code Data Integration Platform

Hevo extracts and loads QuickBooks data, while Python is applied downstream for transformation, analytics, and automation. It eliminates the need to write Python code for QuickBooks API authentication, pagination, rate limits, and schema evolution.

Step 1: Connect QuickBooks Online as a source in Hevo

Hevo provides a native QuickBooks Online connector, which is the recommended approach for ingesting QuickBooks data without writing custom API code.

• Log in to the Hevo dashboard.
• Click Add Source and select QuickBooks Online.
• Provide connection details:

• Pipeline Name: Unique identifier for the data pipeline.
• Authorised Service Account: Account used for source authentication.
• Historical Sync Duration: Time range for initial data load.

• Authenticate using QuickBooks OAuth.
• Select the accounting objects to sync (invoices, customers, payments, etc.)
• Now, choose “TEST & CONTINUE.”

What Hevo does:

• Authenticates with QuickBooks using OAuth 2.0.
• Tracks incremental changes using QuickBooks sync metadata.

Note: If a native connector is unavailable, Hevo supports ingesting QuickBooks data via its REST API source or through a custom connector, available upon request.

Step 2: Configure a destination for data storage

QuickBooks data must be loaded into a database or warehouse before Python-based processing can occur.

• Click Add Destination.
• Choose a supported destination such as Google BigQuery.
• Provide the connection details:

• Destination name: Logical identifier for the target system.
• Authorised User Account: Account with write access permissions.
• Project ID: Unique identifier for the target project.

• Test and save the destination configuration.

Under Advanced Settings, configure the following options based on your requirements:

• Populate Loaded Timestamp: Enable tracking when records are ingested into the destination.
• Sanitize Table/Column Names: Enable if source fields contain spaces or special characters.
• Enable Streaming Inserts: Enable when near real-time data availability is required.

What Hevo does:

• Validates connectivity and write permissions.
• Automatically creates tables for QuickBooks objects.
• Applies schema updates as QuickBooks fields change.

Step 3: Create the QuickBooks → Destination pipeline

Once the source and destination are configured, create the data pipeline.

• Create a new pipeline with QuickBooks as the source and your database as the destination.
• Review auto-generated table mappings.
• Configure the sync mode:
  
  • Real-time streaming for immediate availability
  • Interval-based syncs for controlled frequency
    
• Enable the pipeline.

What Hevo does:

• Extracts QuickBooks data incrementally.
• Normalizes nested API responses into relational tables.
• Manages retries, failures, and API rate limits.

Step 4: Process QuickBooks data using Python

After ingestion, Python is used to consume and process the structured QuickBooks data from the destination.

Python workflow:

import pandas as pd

from sqlalchemy import create_engine

engine = create_engine("postgresql://user:password@host:5432/db")

df = pd.read_sql("SELECT * FROM invoices", engine)

What this enables:

• Clean separation between ingestion and processing.
• Faster development without managing QuickBooks APIs manually.
• Production-ready pipelines with minimal engineering overhead.

Step 5: Pipeline monitoring and reliability

Pipeline monitoring and reliability are managed centrally through Hevo’s dashboard:

• Pipeline health, sync status, and failures are tracked from the Hevo dashboard.
• Automatic alerts notify users of authentication errors, API failures, or load issues.
• Data freshness and last sync timestamps are visible per pipeline.
• Schema changes are detected and managed without manual intervention.

What Hevo does:

Hevo manages QuickBooks ingestion, incremental syncs, schema evolution, and pipeline monitoring, while exposing clean, analytics-ready data for Python-based processing.

Method 2: Direct QuickBooks API Integration Using Python

This method uses Python to interact with the QuickBooks Online REST APIs directly. It offers maximum control over authentication, data extraction, transformations, and sync logic, but requires manual handling of API workflows, error handling, and schema changes.

Step 1: Set up a QuickBooks developer application

To access QuickBooks APIs, you must create an application in the QuickBooks Developer Portal.

• Create a QuickBooks developer account.
• Register a new app and select QuickBooks Online.
• Generate OAuth 2.0 credentials (Client ID and Client Secret).
• Configure redirect URIs and environment.

Workflow:

• QuickBooks issues OAuth credentials required for API access.
• The application is authorized to read accounting objects.

Step 2: Authenticate with QuickBooks using OAuth 2.0

QuickBooks uses OAuth 2.0 to protect customer accounting data, which requires Python to manage token-based authentication.

• Exchange the authorization code for access and refresh tokens.
• Persist tokens securely for reuse across sessions.
• Refresh access tokens automatically to prevent expired requests.

Workflow:

• Python maintains a valid authenticated session.
• API requests remain authorized without manual re-login.

Step 3: Extract data using QuickBooks APIs

After authentication, Python can retrieve accounting data by calling QuickBooks REST endpoints.

import requests

url = f"https://quickbooks.api.intuit.com/v3/company/{realm_id}/query"

query = "SELECT * FROM Invoice"

headers = {

    "Authorization": f"Bearer {access_token}",

    "Accept": "application/json",

    "Content-Type": "application/json"

}

response = requests.post(url, headers=headers, json={"query": query})

data = response.json()

Workflow:

• Constructs a SQL-like query supported by the QuickBooks Query API.
• Sends an authenticated request using the access token.
• Receives invoice records as structured JSON payloads.

Step 4: Handle pagination and incremental syncs

QuickBooks limits the number of records returned per request.

• Use startPosition and maxResults to paginate through large datasets.
• Track timestamps or IDs to fetch only new or updated records.

Workflow:

• Prevents missing or duplicated records.
• Enables efficient incremental data extraction.

Step 5: Transform and persist the data

QuickBooks API responses are nested and require processing before use.

• Normalize JSON responses into tabular structures.
• Apply transformations based on business logic.
• Store the processed data in files, databases, or data warehouses.

Workflow:

• Produces analytics-ready datasets.
• Enables downstream reporting, dashboards, or automation.

Step 6: Monitor and Maintain the Integration

With direct API usage, operational responsibility remains with the developer.

• Handle token expiry and authentication failures.
• Manage API rate limits and retries.
• Update extraction logic when QuickBooks schemas change.

Workflow:

• Ensures long-term reliability of the integration.
• Prevents silent data failures.

Method 3: Using Open-Source ETL Frameworks with Python (Singer)

With tap-quickbooks, data is pulled from the QuickBooks API as structured JSON and written to CSV using Singer Targets, making it suitable for downstream data pipelines. Below, the integration is broken down into four detailed steps:

Step 1: Install the Required Python Packages

In order to set up the Python QuickBooks integration, you will need to install the following Python packages:

• gluestick: An Open-source Python package containing utility functions for ETL. More info on PyPi.
• tap-quickbooks: A Singer Tap (data extraction script) that extracts data from the QuickBooks API. More info on GitHub. 
• target-csv: A Singer Target (data ingestion script) that consumes JSON data and converts it to CSV format. The CSV file format is widely used for storing tabular data. More info on GitHub.
• singer-discover: An Open-source utility that selects streams and fields from a Singer catalog. More info on GitHub.
• pandas: An Open-source Python Library for Data Analysis and Manipulation. More info on their official website.

Step 2: Set Up a Python Virtual Environment

Singer taps often rely on tightly pinned dependencies, which can conflict with other Python projects or even with each other. A dedicated virtual environment ensures dependency isolation and repeatable execution for the QuickBooks integration.

The steps are as follows:

1. Install virtualenv

<em>pip3 install virtualenv</em>

Workflow:

• Installs the tool required to create isolated Python environments.
• Prevents system-wide package conflicts when working with Singer.

2. Create and activate the virtual environment

virtualenv tap-quickbooks

source tap-quickbooks/bin/activate

Workflow:

• Creates a project-specific Python environment named tap-quickbooks.
• Ensures all subsequent package installs are scoped only to this integration.

3. Install Jupyter Lab

<em>pip3 install jupyterlab</em>

Workflow:

• Enables interactive data exploration and transformation.
• Used later to standardize and inspect QuickBooks data using Pandas.

4. Install Singer Tap and Target

pip install git+https://github.com/hotgluexyz/tap-quickbooks.git

pip install git+https://github.com/hotgluexyz/target-csv.git

Workflow:

• Installs tap-quickbooks to extract data from the QuickBooks API.
• Installs target-csv to write extracted JSON data into CSV files.

5. Install data transformation dependencies

<em>pip install gluestick pandas</em>

Workflow:

• gluestick simplifies reading and organizing Singer output files.
• pandas enables data filtering, transformation, and analysis.

6. Install required Singer dependencies

pip install singer-python==5.3.1 \

  prompt_toolkit==1.0.14 \

  requests==2.20.0 \

  xmltodict==0.11.0 \

  jsonpath-ng==1.4.3 \

  pytz==2018.4 \

  attrs==20.2.0 \

  ipykernel

Workflow:

• Pins compatible dependency versions required by Singer and tap-quickbooks.
• Avoids runtime errors caused by mismatched or newer library versions.

7. Register the virtual environment with Jupyter

<em>python -m ipykernel install --user --name=tap-quickbooks</em>

Workflow:

• Makes the virtual environment selectable inside Jupyter Lab.
• Ensures notebooks run using the same dependencies as the Singer pipeline.

8. Create a project workspace

mkdir quickbooks-integration

cd quickbooks-integration

Workflow:

• Organizes configuration files, catalogs, and output data in one location.
• Maintains a structured and repeatable integration setup.

Step 3: Configure the Singer Tap

This step configures tap-quickbooks to authenticate with QuickBooks Online, discover available data objects, and define which streams and fields should be extracted.The steps are as follows:

1. Obtain QuickBooks OAuth credentials

To authenticate with the QuickBooks API, you need OAuth 2.0 credentials generated from the QuickBooks developer dashboard.

Required credentials:

• Client ID: Public identifier for your QuickBooks application.
• Client Secret: Private key used to authenticate API requests.

You can get the OAuth credentials in your application’s Keys and OAuth section under Development or Production.

Workflow:

• Secure, token-based access to QuickBooks Online data.
• API authorization for reading accounting objects such as Invoices, Customers, and Payments.

2. Create the Singer Configuration File

Create a config.json file in your project directory with the following structure:

{

  "client_id": "your_client_id",

  "client_secret": "your_client_secret",

  "refresh_token": "your_refresh_token",

  "start_date": "2020-10-06T00:00:00Z",

  "api_type": "BULK",

  "select_fields_by_default": true,

  "sandbox": true,

  "realmId": "1234567890"

}

Workflow:

• Stores QuickBooks OAuth credentials used by the tap.
• Defines the sync start date for historical data extraction.
• Enables Bulk API usage where supported for efficient data pulls.

3. Discover available QuickBooks streams

Run the Singer discover command to inspect which objects and fields are available through the QuickBooks API.

<em>tap-quickbooks --config config.json --discover > catalog.json</em>

Workflow:

• Queries the QuickBooks API schema.
• Generates a catalog.json file listing all accessible streams and their fields.

4. Inspect the generated catalog

<em>less catalog.json</em>

Workflow:

• Allows you to review available QuickBooks objects (for example, Invoice, Customer).
• Exposes field-level metadata and data types for each stream.

5. Install and configure singer-discover

singer-discover provides an interactive way to select streams and fields from the catalog.

pip install https://github.com/chrisgoddard/singer-discover/archive/master.zip \

  singer-python==5.4.1 \

  prompt_toolkit==1.0.14

Workflow:

• Installs the stream-selection utility.
• Temporarily switches to a Singer version compatible with singer-discover.

6. Select streams and fields

Run the interactive selector:

<em>singer-discover --input catalog.json --output properties.json</em>

Workflow:

• Launches a CLI prompt to choose which streams to sync.
• Allows optional field-level selection per stream.
• Generates a properties.json file that defines the extraction scope.

7. Extract data from QuickBooks

Switch back to the required Singer version and run the extraction:

pip install singer-python==5.3.1

tap-quickbooks --config config.json --properties properties.json | target-csv > state.json

Workflow:

• Pulls data from the selected QuickBooks streams.
• Writes the output to CSV files using target-csv.
• Creates a state.json file to track incremental sync progress.

Step 4: Standardize the data

The data extracted using tap-quickbooks is stored as raw CSV files. This data is standardized into a clean, consistent structure.

1. Load data into Jupyter Lab

Start a Jupyter Lab instance by running the following command:

<em>jupyter lab</em>

Once Jupyter Lab is running, load the Singer-generated CSV files into a Pandas DataFrame for inspection and transformation.

mport gluestick as gs

import pandas as pd

input_data = gs.read_csv_folder(".", index_cols={'Invoice': 'Id'})

input_df = input_data['Invoice']

Workflow:

• Loads Singer-generated CSV files into a Pandas DataFrame.
• Prepares the data for inspection and transformation.

2. Select required fields

invoices = input_df[

    ["CustomerRef__name", "TotalAmt", "Balance", "DueDate"]

]

Workflow:

• Produces an analysis-ready dataset.
• Filters relevant columns from the raw QuickBooks schema.

What is Python?

Python is one of the most popular general-purpose programming languages that was released in 1991 and was created by Guido Van Rossum. It can be used for a wide variety of applications such as Server-side Web Development, System Scripting, Data Science and Analytics, Software Development, etc. 

Python is an Interactive, Interpreted, Object-Oriented programming language that incorporates Exceptions, Modules, Dynamic Typing, Dynamic Binding, Classes, High-level Dynamic Data Types, etc. It can also be used to make system calls to almost all well-known Operating Systems.

Understanding the Key Features of Python

Some of the most well-known features of Python are as follows:

• Free and Open-Source: Python is available free of cost for everyone and can easily be downloaded and installed. Open-Source means that the source code is openly available. This gives users with enough knowledge the ability to make changes to the code as per business use cases and product requirements.
• Easy to Code and Read: Python is considered to be a very beginner-friendly language and hence, most people with basic programming knowledge can easily learn the Python syntax in a few hours. 
• High-Level: While using Python, developers do not need to have any information on the System Architecture or manage memory usage manually. All this is automatically handled by the Python Interpreter.
• Portable: A Python code written on one system can easily be transferred to another system and can run without any issues.
• Interpreted: Python code is processed by the Interpreter at runtime. This means that users do not need to compile the code and then run it like other programming languages such as Java, C/C++, etc.
• Object-Oriented: Python also has support for the Object-Oriented Programming Paradigm which allows users to write readable and reusable code.

What is Quicbooks?

QuickBooks is a popular accounting software that was developed by the leading financial software developer, Intuit. It is used to manage business finances primarily by small and mid-sized businesses. QuickBooks allows users to manage Sales and expenses, file taxes, generate reports as per their requirement, etc. In addition, the accountancy software offers numerous in-built reports that can easily be customized and gives businesses the ability to take complete control of their finances. QuickBooks is used by businesses to perform the following operations:

• Track income and expenses.
• Keep track of daily transactions.
• Generate reports for planning.
• Prepare billings.
• Manage payroll.

Understanding the Key Features of QuickBooks

The key features of QuickBooks are as follows:

• Online Banking: With the QuickBooks Online Software banking integration feature, statements and transactions will automatically be updated.
• Cloud Accounting: QuickBooks allows users to access their accounts, manage their business anywhere on their mobile, computer, or tablet.
• Invoicing: Users can create custom and professional invoices, sales receipts, and estimates seamlessly within minutes using QuickBooks.
• Cash Flow Management: QuickBooks houses functionality that allows businesses to save bills from vendors and schedule recurring payments for when they are due.
• Accounting Reports: Embedded Analytics to instantly understand how your business is performing with customizable dashboards and reports.

Conclusion

This article provided you with a step-by-step guide on how you can set up Python QuickBooks integration seamlessly. There are certain limitations associated with this method. This includes the fact that this method is not considered to be suitable for someone with not enough technical knowledge of Python. If the limitations are not a concern to your requirements, then the manual Python QuickBooks integration method is the best option for you, but if it is, then you should consider using automated Data Integration platforms like Hevo.

Hevo helps you directly transfer data from a source of your choice to a Data Warehouse, Business Intelligence tools, or desired destination in a fully automated and secure manner without having to write the code. It will make your life easier and make data migration hassle-free. It is User-Friendly, Reliable, and Secure.

Sign up for a 14-day free trial and simplify your data integration process. Check out the pricing details to understand which plan fulfills all your business needs.

Frequently Asked Questions (FAQs)