# Agentic Accounting
Source: https://docs.tight.com/ai/agentic/agentic-accountant

Enable autonomous AI agents to handle end-to-end accounting workflows

<Tip>
  This functionality is actively evolving. Please check back regularly for updated content.
</Tip>

## Continuous bank account reconciliation

Tight automatically pulls account balances on an ongoing basis and validates them against the corresponding General
Ledger balances to detect discrepancies as early as possible. Additionally, once bank statements are available, Tight
programmatically ingests these from the underlying bank integration and parses out the relevant dates, balances, and
individual transactions to automatically perform the monthly reconciliation process per linked bank account. Through
these two types of automated reconciliations, Tight removes the manual labor that is required in legacy accounting
systems to perform monthly bank account reconciliations.

## Agentic book closings

**Tight Agentic Accountant** performs book closings on a recurring basis (monthly, quarterly, and annual) and provides
financial summaries for the closed period. Business owners can review these summaries and subsequently converse with the
agent about their company’s books, including making modifications when needed.

<Tip> The timing of agentic closings can be configured in the [company's AI settings](https://docs.tight.com/api-reference/agentic-accounting-settings/save-agentic-accountant-settings/api-reference/agentic-accounting-settings/save-agentic-accountant-settings)</Tip>

## CFO-level trend analysis

**Tight Agentic CFO** is trained to provide CFO-level trend analysis using the business’s historical financial data.
Business owners receive performant real-time replies on interesting trends across *all* of their historical data,
including data imported from QBO, Xero, and Wave, beyond the capabilities of most human beings.

## Anomaly detection

**Tight Agentic Bookkeeper** reviews General Ledger balances ongoing to detect anomalous transactions. **Tight Agentic
Bookkeeper** surfaces these transactions to the end-user along with a proposed modification to clear the anomaly if
necessary. This enables users to keep a close eye on their business without reviewing every single transaction.

## Conversational reasoning

When Tight’s categorization engine is unable to categorize a transaction with sufficient confidence, **Tight Agentic
Bookkeeper** reaches out to the end user with questions about the transaction, e.g., “Did you meet with a client for
this
Starbucks charge?” The end user is able to reason with the agentic accountant via a conversation to categorize and
reconcile the transaction.


# Leveraging 1.3M+ SMBs
Source: https://docs.tight.com/ai/categorization/self-learning-transaction-categorization-overview

AI-powered transaction categorization that learns from 1.3M+ SMBs' worth of data

[Tight's AI-first architecture](/ai/philosophy/ai-native-general-ledger#creating-an-ai-native-architecture) has the benefit of learning from the behaviors of the 1.3M+ SMBs and 3k+ bookkeepers that have used Tight to categorize their transactions.

Given the importance of seeing real bookkeeper categorization behavior, Tight has the distinct advantage of being able to combine the latest in AI/learning technology with (anonymized) data from the 1.3M+ SMBs in the Tight database, all already segmented by business type so that all learnings are properly contextualized.

## New Transaction Ingestion Flow

```mermaid theme={null}
flowchart TD
    Start([New Transaction Ingested]) --> ReconciliationEngine

    subgraph ReconciliationEngine[**Tight Reconciliation Engine**]
        MatchEntity{"Transaction reconciled as <br/>• Bank Transfer<br/>• Bill (A/P) Payment<br/>• Expense<br/>• Invoice (A/R) Payment<br/>• Payout<br/>• Refund<br/>• Revenue<br/>• Tax Payment<br/>"}
        MatchEntity -->|Yes|SetReconciled[Set reviewStatus = RECONCILED]
        MatchEntity ~~~ ToRules[ ]
    end

    ToRules ~~~ RuleEngine
    MatchEntity -->|No|BizRule

    subgraph RuleEngine[**Tight Rules Engine**]
        BizRule{Check against<br/>business-level rules}
        BizRule -->|Match found|ApplyRule[Apply rule and set reviewStatus based on confidence level]
        BizRule -->|No match|CPRule{Check against<br/>Partner-level rules based on business type}
        CPRule -->|Match found|ApplyRule
        CPRule -->|No match|TightLevelRule{Check against<br/>Tight-level rules based on 1.3M+ SMBs and 3k+ bookkeepers}
        TightLevelRule -->|Match found|ApplyRule
    end

    TightLevelRule -->|No match|Done
    ApplyRule --> Done

    SetReconciled --> Done
    Done([Done])

    style MatchEntity fill:#caecf3,color:#000000
    style ReconciliationEngine fill:#f8f9f9,color:#000000
    style RuleEngine fill:#f8f9f9,color:#000000
    style BizRule fill:#caecf3,color:#000000
    style CPRule fill:#caecf3,color:#000000
    style TightLevelRule fill:#caecf3,color:#000000
    style Start fill:#e1f5e1,color:#000000
    style Done fill:#bfe6dc,color:#000000
    style SetReconciled fill:#d7fce9,color:#000000
    style ApplyRule fill:#d7fce9,color:#000000
    style ToRules fill:none,stroke:none,color:#000000
```

## Rule Insertion Flow

As Tight adjusts its heuristics to leverage the latest in rapidly evolving AI technologies, it reruns the user/bookkeeper actions taken upon the transactions of 1.3M SMBs in order to retrain the Tight Rules Engine:

```mermaid theme={null}
flowchart TD
    Start([Transaction Edited]) --> BusinessLearning

    subgraph BusinessLearning[**Business-level Learning**]
        BizCheck{Check confidence against conflicting rules for similar transactions within the business}
        BizCheck -->|High confidence against conflicting rule| UpdateRule[Update rule to<br/>automate user's edit]
        BizCheck -->|No conflicting rule| InsertBizRule[Insert business-level rule<br/>to automate user's edit]
    end
    BizCheck --> |Low confidence with conflicting rule| QueueForPotentialLearning[Queue for potential<br/>future learning]


    InsertBizRule --> PartnerLearning
    UpdateRule --> PartnerLearning

    subgraph PartnerLearning[**Partner-level Learning**]
        PartnerCheck{Check confidence against rules for similar businesses within the given Partner}
        PartnerCheck -->|High confidence| InsertPartnerRule[Insert Partner-level rule<br/>to automate edit for all users]
        PartnerCheck -->|Low confidence| NoPartnerRule[No Partner-level rule needed]
    end

    InsertPartnerRule --> TightLearning
    NoPartnerRule --> Done

    subgraph TightLearning[**Tight-level Learning**]
        TightCheck{Check confidence against rules for all Partners within the Tight database}
        TightCheck -->|High confidence| InsertTightRule[Insert Tight-level rule<br/>to automate edit for all partners]
        TightCheck -->|Low confidence| NoTightRule[No Tight-level rule needed]
    end

    QueueForPotentialLearning --> Done

    InsertTightRule --> Done
    NoTightRule --> Done


    Done([Learning Complete])

    style Start fill:#e1f5e1,color:#000000
    style Done fill:#bfe6dc,color:#000000
    style BizCheck fill:#caecf3,color:#000000
    style PartnerCheck fill:#caecf3,color:#000000
    style TightCheck fill:#caecf3,color:#000000
    style BusinessLearning fill:#f8f9f9,color:#000000
    style PartnerLearning fill:#f8f9f9,color:#000000
    style TightLearning fill:#f8f9f9,color:#000000
    style UpdateRule fill:#d7fce9,color:#000000
    style InsertBizRule fill:#d7fce9,color:#000000
    style InsertPartnerRule fill:#d7fce9,color:#000000
    style InsertTightRule fill:#d7fce9,color:#000000
    style NoPartnerRule fill:#d7fce9,color:#000000
    style QueueForPotentialLearning fill:#d7fce9,color:#000000
    style NoTightRule fill:#d7fce9,color:#000000
```

The flows above give a high-level overview into how Tight is able to leverage its history to provide the best categorization outcomes. These outcomes get smarter every day.<br /><br />The specific types of rules that Tight creates are proprietary, evolve regularly, and have been purposefully excluded from the above diagrams.
<Tip>Any given transaction can be audited via the API and Embeddable UI so that your team or your user can understand why a given transaction was categorized a specific way.</Tip>


# Bank Transactions
Source: https://docs.tight.com/ai/mcp-tools/bank-transactions-mcp

Query and analyze bank transactions using Model Context Protocol tools

## Overview

Tight Bank Transactions MCP tools enable AI assistants and agents to search, review, and update bank transactions. This allows users to categorize transactions, add notes, and request bookkeeper reviews, all through conversational AI interactions.

With these tools, you can build AI-powered accounting experiences where users ask questions like "Show me all uncategorized transactions from last month" or "Categorize this coffee shop expense as a recruitment expense."

## Available Tools

### Query Bank Transactions

The `query_bank_transactions` tool searches for bank transactions based on multiple criteria. You can filter transactions by amount, date, description, vendor, category, review status, and more.

<Accordion title="Parameters">
  <ParamField type="number | range">
    Search for transactions with a specific amount or within an amount range (e.g., "\$50-\$100")
  </ParamField>

  <ParamField type="date | date range">
    Filter transactions by specific date or date range (e.g., "last month", "January 2025", "2025-01-01 to 2025-01-31")
  </ParamField>

  <ParamField type="string">
    Fuzzy search on the bank description field
  </ParamField>

  <ParamField type="string">
    Fuzzy search on user-added notes attached to transactions
  </ParamField>

  <ParamField type="string">
    Filter transactions belonging to specific dimension values
  </ParamField>

  <ParamField type="string">
    Search for transactions associated with specific vendors or customers
  </ParamField>

  <ParamField type="string">
    Filter transactions by accounting category or account (e.g., "Meals & Entertainment", "Office Supplies")
  </ParamField>

  <ParamField type="object">
    Search for transactions that are split across multiple categories or amounts
  </ParamField>

  <ParamField type="string">
    Filter by review status (e.g., "needs review", "reviewed by bookkeeper", "pending bookkeeper review")
  </ParamField>

  <ParamField type="string">
    Filter by transaction type: Expense, Revenue, Transfer, Tax Payment, Invoice Payment, Bill Payment, etc.
  </ParamField>
</Accordion>

<Tip>
  You can combine multiple search criteria to narrow results. For example, search for "uncategorized expenses over \$100 from last week" by combining amount, date, category, and type filters.
</Tip>

### Get Bank Transaction Details

The `get_bank_transaction` tool retrieves detailed information about a specific bank transaction. Use this tool to inspect transaction details before making updates or to discuss categorization decisions with the user.

This tool returns comprehensive transaction data including:

* Transaction amount and date
* Bank description and user-added notes
* Current categorization (vendor, category, dimensionValue)
* Split information if applicable
* Review status and history
* Related invoice or bill payments
* Attachments and receipts

<Note>
  This tool is essential for conversational workflows where users want to discuss a specific transaction with the AI before making changes. The detailed context helps the AI provide informed categorization suggestions.
</Note>

### Update Bank Transaction

The `update_bank_transaction` tool modifies any field on a bank transaction. This is the primary tool for categorizing expenses, adding notes, splitting transactions, and managing review workflows.

<Accordion title="Parameters">
  <ParamField type="string">
    Assign or update the dimension value for tracking transactions across different parts of the business
  </ParamField>

  <ParamField type="string">
    Set or update the vendor or customer associated with the transaction
  </ParamField>

  <ParamField type="string">
    Update the accounting category or account for the transaction (e.g., "Travel", "Office Supplies", "Professional Services")
  </ParamField>

  <ParamField type="array">
    Split a transaction across multiple categories, dimensionValues, or customers. Each split can have its own amount, category, and allocation.
  </ParamField>

  <ParamField type="string">
    Request review from a bookkeeper or mark a transaction as reviewed
  </ParamField>

  <ParamField type="string">
    Add or update notes on the transaction for additional context or documentation
  </ParamField>
</Accordion>

## Common Workflows

### Categorizing Transactions Needing Review

One of the most common workflows is identifying transactions that need categorization and applying the appropriate category:

1. **Query** for transactions needing review using `query_bank_transactions` with the `reviewStatus` filter set to "NEEDS\_REVIEW"
2. **Review** each transaction using `get_bank_transaction` to understand the context
3. **Update** the transaction with the appropriate category using `update_bank_transaction`

This workflow helps business owners stay on top of their bookkeeping by ensuring all transactions are properly categorized for tax reporting and financial analysis.

### Splitting Complex Transactions

Some transactions need to be split across multiple categories or business segments:

1. **Get** the full transaction details to understand the total amount
2. **Update** with split information, specifying amounts and categories for each split
3. **Add notes** documenting the reason for the split

<Tip>
  Splits are common for transactions like business trips (split between travel, meals, and lodging) or bulk purchases from retailers like Amazon (split by category: office supplies, equipment, etc.).
</Tip>

## Examples

### "What transactions need my review?"

**AI uses:** `query_bank_transactions` with:

* `reviewStatus`: "needs review"

**AI responds:** "You have 8 transactions that need your review. Here are the highlights:

* \$1,245.00 from 'TECH SOLUTIONS INC' on January 10th
* \$687.50 from 'AMAZON.COM' on January 9th
* \$450.00 from 'OFFICE DEPOT' on January 8th

Would you like me to walk through these one by one?"

***

### "Can you recategorize this transaction as Business Meals?"

**AI uses:** `update_bank_transaction` with:

* `category`: "Business Meals"

**AI responds:** "I've recategorized this transaction as Business Meals. The \$67.43 expense from 'OLIVE GARDEN' on January 11th is now properly categorized in your books."

<Note>
  The AI should identify which transaction the user is referring to from context in the conversation. If ambiguous, the AI should use `query_bank_transactions` to find the most recent transaction or ask for clarification.
</Note>

***

### "What was my most recent transaction from Ace Hardware?"

**AI uses:** `query_bank_transactions` with:

* `vendor`: "Ace Hardware" or `description`: "Ace Hardware"
* Sort by date (most recent first)
* Limit to 1 result

**AI responds:** "Your most recent transaction from Ace Hardware was \$124.87 on January 9th. It's currently categorized as 'Repairs & Maintenance'. The bank description shows 'ACE HARDWARE #2847'. Would you like to see more details or update the categorization?"

***

### "Can you find all transactions similar to the one I just edited?"

**AI uses:** Multiple `query_bank_transactions` calls based on the recently edited transaction's attributes:

* Same vendor
* Similar amount range (±20%)
* Same or similar description pattern
* Within a relevant time window

**AI responds:** "I found 5 transactions similar to the one you just edited (the \$89.00 'SHELL GAS STATION' transaction you categorized as 'Vehicle Expenses'):

1. \$92.50 from 'SHELL GAS STATION' on January 8th - currently uncategorized
2. \$85.00 from 'SHELL GAS STATION' on January 5th - currently uncategorized
3. \$78.45 from 'SHELL GAS STATION' on December 29th - categorized as 'Auto & Travel'
4. \$95.20 from 'CHEVRON' on January 7th - currently uncategorized
5. \$88.00 from 'BP GAS' on January 4th - currently uncategorized

Would you like me to categorize all the uncategorized gas station purchases as 'Vehicle Expenses'?"


# Embedding & Integration
Source: https://docs.tight.com/ai/mcp-tools/embedding-and-integration-mcp

Embed accounting functionality into your platform using the Tight Model Context Protocol (MCP) server

## Overview

Tight Embedding & Integration MCP tools enable AI assistants and agents to interact with the Tight API, embed user
experiences, and search its documentation.

## Available Tools

### Search Tight Documentation

The `search_tight_documentation` tool searches across Tight's full documentation, including API references, integration
guides, and embeddable UI component docs. Use this tool to answer questions, look up parameters, and find working code
examples as you build.

<Tip>
  Connect your editor's AI agent (e.g., Claude Code, Cursor, VS Code Copilot) to Tight's MCP server so it can answer Tight-specific questions inline as you write code. See the [MCP Overview](/ai/mcp-tools/mcp-overview) for setup instructions.
</Tip>


# End User Support
Source: https://docs.tight.com/ai/mcp-tools/end-user-support-mcp

Support end-user inquiries in your platform using the Tight Model Context Protocol (MCP) server

## Overview

Tight End User Support MCP tools enable AI assistants and agents to search knowledge base and support content,
contextualized with the user's data.

## Available Tools

### Search Tight End User Support

The `search_tight_end_user_support` tool searches across
[Tight's full knowledge base and support content](/guides/get-started/launch-checklist/ai-support#knowledge-base). Use
this tool to handle user support inquires and to understand how to accomplish product use cases.

### Search Tight Bookkeeper Support

The `search_tight_bookkeeper_support` tool similarly searches across Tight's full knowledge base and support content
with a focus on bookkeeper-facing features, e.g. [Team Management](/guides/bookkeepers/team-management).

## Integrating into existing AI support

Many AI support agents support adding MCP tools via custom connectors, e.g.
[Intercom's Fin](https://www.intercom.com/help/en/articles/11461635-add-mcp-connectors-for-popular-apps-or-custom-mcps).
Adding the Tight MCP `search_tight_end_user_support` tool to your AI support agent will enable it to handle your user's
accounting support inquiries.


# Financial Statements
Source: https://docs.tight.com/ai/mcp-tools/financial-statements-mcp

Access and analyze balance sheets, P&L statements, and cash flow reports through Model Context Protocol

## Overview

Tight Financial Statements MCP tools enable AI assistants and agents to access and analyze comprehensive financial reports. Users can pull real-time financial statements and perform advanced analysis, all through conversational AI interactions.

With these tools, you can build AI-powered financial analysis experiences where users ask questions like "Show me our Q4 P\&L by department" or "How has our cash position changed over the past year?"

## Available Tools

### Generate Profit & Loss

The `generate_profit_and_loss` tool generates a Profit & Loss (P\&L) report with customizable parameters. This report shows revenue, expenses, and net income over a specified period.

<Accordion title="Parameters">
  <ParamField type="string | array">
    Filter the report by dimensions to see performance by category
  </ParamField>

  <ParamField type="object">
    Specify the start and end dates for the report period (e.g., "2024-01-01 to 2024-12-31", "Q4 2024", "last year")
  </ParamField>

  <ParamField type="string">
    Organize the report by time period: "Yearly", "Quarterly", "Monthly", or "None"
  </ParamField>

  <ParamField type="string">
    Choose the format of the report output: "PDF" or "XLS"
  </ParamField>
</Accordion>

<Tip>
  The AI can analyze P\&L reports to compare performance across periods and/or [dimensions](/guides/business-owners/dimensions), analyze growth trends, and correlate trends across P\&L line items.
</Tip>

### Generate Balance Sheet

The `generate_balance_sheet` tool generates a Balance Sheet report showing assets, liabilities, and equity at specific points in time.

<Accordion title="Parameters">
  <ParamField type="object">
    Specify the start and end dates for the report period
  </ParamField>

  <ParamField type="string">
    Organize the report by time period: "Yearly", "Quarterly", "Monthly", or "None"
  </ParamField>

  <ParamField type="string">
    Choose the format of the report output: "PDF" or "XLS"
  </ParamField>
</Accordion>

<Tip>
  The AI can analyze Balance Sheets to monitor debt and leverage, track liquidity and cash position, and assess financial stability over time.
</Tip>

### Generate Cash Flow Statement

The `generate_cash_flow_statement` tool generates a Cash Flow Statement showing cash inflows and outflows from operating, investing, and financing activities.

<Accordion title="Parameters">
  <ParamField type="object">
    Specify the start and end dates for the report period
  </ParamField>

  <ParamField type="string">
    Organize the report by time period: "Yearly", "Quarterly", "Monthly", or "None"
  </ParamField>

  <ParamField type="string">
    Choose the format of the report output: "PDF" or "XLS"
  </ParamField>
</Accordion>

<Tip>
  The AI can analyze Cash Flow Statements to identify drivers of cash flow changes, track trends over time, and understand timing or operational factors behind fluctuations.
</Tip>

## Common Workflows

### Analyzing P\&L Performance

AI assistants can perform comprehensive P\&L analysis by pulling reports and analyzing the data:

1. **Compare performance across periods**: Analyze changes in revenue, expenses, and net income between different periods (e.g., month-over-month, year-over-year)
2. **Compare performance across dimensions**: Evaluate revenue, expense, or profit across different dimensions
3. **Analyze growth trends**: Identify upward or downward trends in revenue, expense, or net income over time
4. **Correlate trends across line items**: Examine relationships between different line items or dimensions to understand drivers of performance

This workflow helps business owners understand financial performance trends, identify areas of strength or concern, and make data-driven decisions.

### Monitoring Balance Sheet Health

AI assistants can assess financial stability and risk by analyzing Balance Sheet data:

1. **Debt analysis and leverage monitoring**: Track total liabilities, debt-to-equity ratios, and leverage trends over time to assess financial stability and identify potential risk exposure
2. **Cash position and liquidity tracking**: Analyze short-term assets versus liabilities to understand liquidity health, operating runway, and ability to meet near-term obligations

This workflow helps business owners monitor financial health, assess risk levels, and plan for future capital needs.

### Understanding Cash Flow Drivers

AI assistants can identify what's driving changes in cash position:

1. **Identify drivers of cash flow changes**: Break down changes in operating, investing, and financing cash flows to understand what's driving fluctuations in total cash position
2. **Track cash flow trends over time**: Analyze rolling periods (e.g., trailing twelve months) to identify timing or operational factors behind cash flow swings that may not be evident from other financial reporting

This workflow helps business owners understand cash dynamics, identify potential cash flow issues early, and plan for cash needs.

## Examples

### "Show me our P\&L for Q4 2024"

**AI uses:** `generate_profit_and_loss` with:

* `dateRange`: "Q4 2024" (October 1 - December 31, 2024)
* `grouping`: "Monthly"
* `output`: "PDF"

**AI responds:** "Here's your Profit & Loss statement for Q4 2024, broken down by month:

**Q4 2024 Summary:**

* Total Revenue: \$487,250
* Total Expenses: \$342,180
* Net Income: \$145,070

**Monthly Breakdown:**

* October: \$162,400 revenue, \$114,220 expenses, \$48,180 net income
* November: \$158,900 revenue, \$112,340 expenses, \$46,560 net income
* December: \$165,950 revenue, \$115,620 expenses, \$50,330 net income

Your Q4 performance shows consistent profitability with a 29.8% net margin. Would you like me to compare this to Q3 or analyze specific expense categories?"

***

### "How did our revenue compare to last quarter?"

**AI uses:** `generate_profit_and_loss` with:

* `dateRange`: "Q3 2024" and "Q4 2024"
* `grouping`: "Quarterly"

**AI responds:** "Your revenue increased from Q3 to Q4 2024:

**Q3 2024:** \$452,300
**Q4 2024:** \$487,250
**Change:** +\$34,950 (+7.7%)

This represents solid quarter-over-quarter growth. Breaking down the increase:

* October started strong at \$162,400
* November dipped slightly to \$158,900
* December recovered to \$165,950, your highest month in Q4

The 7.7% growth exceeds typical seasonal patterns. Would you like me to analyze which revenue categories drove this increase?"

***

### "What's our current cash position?"

**AI uses:** `generate_balance_sheet` with:

* `dateRange`: "current date"
* `grouping`: "None"

**AI responds:** "As of January 15, 2025, here's your cash position:

**Cash & Cash Equivalents:** \$1,527,600

**Liquidity Analysis:**

* Current Assets: \$1,598,850
* Current Liabilities: \$456,800
* Current Ratio: 3.5 (healthy - above 2.0 threshold)
* Quick Ratio: 3.2

**Operating Runway:** Based on your average monthly expenses of \~\$114,000, you have approximately 13.4 months of runway with current cash reserves.

Your liquidity position is strong. You have sufficient cash to cover near-term obligations and working capital needs. Would you like me to analyze how your cash position has changed over the past year?"

***

### "Analyze our debt-to-equity ratio trend over the past year"

**AI uses:** `generate_balance_sheet` with:

* `dateRange`: "2024-01-01 to 2024-12-31"
* `grouping`: "Quarterly"

**AI responds:** "Here's your debt-to-equity ratio trend for 2024:

* **Q1 2024:** 0.65 (Total Debt: \$142,000 | Total Equity: \$218,000)
* **Q2 2024:** 0.58 (Total Debt: \$138,500 | Total Equity: \$239,000)
* **Q3 2024:** 0.52 (Total Debt: \$135,200 | Total Equity: \$260,000)
* **Q4 2024:** 0.47 (Total Debt: \$131,800 | Total Equity: \$280,500)

**Key Findings:**

* Your debt-to-equity ratio improved by 28% over the year (0.65 → 0.47)
* Total debt decreased by \$10,200 (7.2% reduction)
* Total equity increased by \$62,500 (28.7% growth)
* Your Q4 ratio of 0.47 indicates low financial leverage and strong equity position

This is a positive trend showing you're reducing reliance on debt while growing equity through retained earnings. Your current ratio is well below the 1.0 threshold that typically signals higher financial risk."

***

### "Why did our cash flow drop last month?"

**AI uses:** `generate_cash_flow_statement` with:

* `dateRange`: "last 2 months"
* `grouping`: "Monthly"

**AI responds:** "Analyzing your cash flow for November and December 2024:

**November 2024:**

* Operating Cash Flow: +\$42,300
* Investing Cash Flow: -\$8,200
* Financing Cash Flow: -\$12,100
* **Net Cash Flow: +\$22,000**

**December 2024:**

* Operating Cash Flow: +\$38,500 (↓ \$3,800)
* Investing Cash Flow: -\$24,600 (↓ \$16,400)
* Financing Cash Flow: -\$12,100 (no change)
* **Net Cash Flow: +\$1,800 (↓ \$20,200)**

**Key Drivers of December Drop:**

1. **Increased Investing Activities (-\$16,400)**: You spent \$24,600 on investing activities in December vs. \$8,200 in November. This appears to be equipment or capital purchases.

2. **Slight Operating Cash Flow Decrease (-\$3,800)**: Operating cash flow dipped 9% due to the timing of receivables collections—you had more outstanding invoices at year-end.

The drop is primarily driven by one-time capital investments, not operational issues. Your operating cash flow remains healthy at \$38,500. Would you like me to review your accounts receivable aging to address the collection timing?"


# Invoicing
Source: https://docs.tight.com/ai/mcp-tools/invoicing-mcp

Create, update and query invoices using Model Context Protocol tools

## Overview

Tight Invoicing MCP tools enable AI assistants and agents to search, review, and manage invoices. Users can find invoices by customer, status, or amount, create new invoices with line items and payment plans, and update existing invoices, all through conversational AI interactions.

With these tools, you can build AI-powered invoicing experiences where users ask questions like "Show me all overdue invoices" or "Create an invoice for my client with a payment plan."

## Available Tools

### Query Invoices

The `query_invoices` tool searches for invoices based on multiple criteria. You can filter by customer, amount, date, invoice number, status, line items, payment plans, outstanding balance, and more.

<Accordion title="Parameters">
  <ParamField type="string">
    Search for invoices by specific customer
  </ParamField>

  <ParamField type="number | range">
    Search on total invoice amount or within an amount range (e.g., "\$500-\$2000")
  </ParamField>

  <ParamField type="date | date range">
    Filter invoices by invoice date or date range (e.g., "last quarter", "January 2025", "2025-01-01 to 2025-03-31")
  </ParamField>

  <ParamField type="date | date range">
    Filter invoices by due date or date range to find upcoming or past due payments
  </ParamField>

  <ParamField type="string">
    Search by specific invoice number or invoice full invoice name
  </ParamField>

  <ParamField type="string">
    Filter by invoice status: Draft, Sent, Paid, Overdue, Partially Paid, or Void
  </ParamField>

  <ParamField type="string">
    Search for invoices containing specific services or expenses in line item descriptions
  </ParamField>

  <ParamField type="boolean">
    Filter invoices that have payment plans
  </ParamField>

  <ParamField type="number | range">
    Search for invoices with specific outstanding balance amounts or ranges (e.g., "\$100-\$1000")
  </ParamField>

  <ParamField type="string">
    Fuzzy search for text in line item descriptions or invoice notes
  </ParamField>
</Accordion>

<Tip>
  You can combine multiple search criteria to narrow results. For example, search for "overdue invoices over \$1,000 from customer ABC Corp" by combining status, amount, and customer filters.
</Tip>

### Get Invoice Details

The `get_invoice` tool retrieves detailed information about a specific invoice. Use this tool to review invoice details before making updates or to discuss pricing and payment terms with the user.

This tool returns comprehensive invoice data including:

* Customer information and contact details
* Invoice date, due date, and invoice number
* Line items with descriptions, quantities, rates, and amounts
* Service items and reimbursable expense items
* Sales tax calculations per line item
* Installment schedules and dates
* Payment history and current status
* Outstanding balance
* Discounts applied (percentage or fixed amount)
* Invoice notes, terms, and payment instructions

<Note>
  This tool is essential for conversational workflows where users want to discuss a specific invoice with the AI before making changes. The detailed context helps the AI provide informed suggestions about pricing, payment terms, or modifications.
</Note>

### Save Invoice

The `save_invoice` tool creates new invoices or updates existing ones. This is the primary tool for managing invoices, adding line items, setting up payment plans, applying discounts, and managing invoice status.

<Accordion title="Parameters">
  <ParamField type="string">
    Assign or change the invoice customer by name or ID
  </ParamField>

  <ParamField type="array">
    Add, modify, or remove line items. Each line item includes:

    * **description**: Description of the service or product
    * **quantity**: Number of units
    * **rate**: Price per unit
    * **amount**: Total line item amount (quantity × rate)
    * **expense** (optional): Reference to an expense for reimbursement
    * **salesTaxPercentage** (optional): Sales tax percentage for this line item
  </ParamField>

  <ParamField type="object">
    Set up or modify payment schedules breaking the total into installments. Each installment includes an amount and date.
  </ParamField>

  <ParamField type="date">
    Invoice date displayed on the invoice; also used for double-entry accounting purposes
  </ParamField>

  <ParamField type="date">
    Set or update payment terms and due date for the invoice
  </ParamField>

  <ParamField type="string">
    Add or edit invoice notes, payment instructions, or terms and conditions
  </ParamField>

  <ParamField type="object">
    Apply, modify, or remove percentage or fixed amount discounts. Specify either a percentage (e.g., 10%) or a fixed dollar amount (e.g., \$50).
  </ParamField>

  <ParamField type="string">
    Update invoice status (only for existing invoices): Draft, Sent, Paid, Overdue, Partially Paid, or Void
  </ParamField>
</Accordion>

<Warning>
  When creating or updating invoices, ensure you have reviewed the customer information and line item details to ensure accuracy. Incorrect amounts or payment terms can lead to payment delays and customer confusion.
</Warning>

## Common Workflows

### Sending a Quote

Quotes help business owners quickly provide pricing estimates to prospective or existing customers before work begins:

1. **Gather** information about the customer and proposed services or products
2. **Create** a draft invoice using `save_invoice` with customer, line items, and pricing
3. **Share** the quote with the customer for review and approval

This workflow enables business owners to respond quickly to quote requests and formalize pricing discussions.

<Tip>
  Quotes are particularly useful for service-based businesses responding to RFPs or providing estimates for project work. Business owners can create multiple quote versions with different pricing scenarios before finalizing.
</Tip>

### Creating Invoices for Completed Work

One of the most common workflows is creating invoices for services rendered or products delivered:

1. **Gather** information about the customer, services provided, and pricing
2. **Create** the invoice using `save_invoice` with customer, line items, date, and due date
3. **Review** the invoice details using `get_invoice` to confirm accuracy before sending

This workflow helps business owners quickly bill clients for completed work while ensuring all details are correct.

### Setting Up Payment Plans

For larger invoices, offering payment plans can improve customer relationships and payment success:

1. **Get** the invoice details to understand the total amount
2. **Update** with installment information using `save_invoice`, specifying installment amounts and dates
3. **Add notes** documenting the payment schedule agreement

Payment plans are common for professional services, large projects, or ongoing retainers where clients prefer to spread payments over time.

## Examples

### "Send a quote to Ruth Smith for \$12k bathroom remodeling. Include a 3k down payment."

**AI uses:** `save_invoice` with:

* `customer`: "Ruth Smith"
* `lineItems`:
  * description: "Bathroom Remodeling", quantity: 1, rate: 12000, amount: 12000
* `installments`:
  * amount: 3000, date: "2025-02-01" (down payment)
  * amount: 9000, date: "2025-03-15" (final payment)
* `date`: today's date
* `notes`: "Quote valid for 30 days. \$3,000 down payment required to begin work."

**AI responds:** "I've created a quote (QUO-1252) for Ruth Smith for bathroom remodeling:

**Total Amount:** \$12,000.00

**Payment Terms:**

* Down payment: \$3,000.00 due February 1, 2025
* Final payment: \$9,000.00 due March 15, 2025

The quote is currently in Draft status. Once Ruth approves, I can update the status to Sent and you can begin work."

***

### "Draft invoice to Joe's Photography for the 1/15 expense with a 20 percent markup and \$1,000 in labor."

**AI uses:** `save_invoice` with:

* `customer`: "Joe's Photography"
* `lineItems`:
  * description: "Materials (expense from 1/15)" with the `expenseId` from Bank Transactions
  * description: "Labor", quantity: 1, rate: 1000, amount: 1000
* `date`: today's date

**AI responds:** "I've created draft invoice INV-1253 for Joe's Photography:

**Line Items:**

1. Materials (expense from 1/15): \$180.00 (marked up 20% from \$150.00)
2. Labor: \$1,000.00

**Total:** \$1,180.00

The invoice is in Draft status. Would you like to set a due date or add any notes before sending?"

***

### "Add a 10 percent discount to that invoice"

**AI uses:** `save_invoice` with:

* Invoice ID from context (INV-1253)
* `discount`: percentage: 10

**AI responds:** "I've added a 10% discount to INV-1253. Here's the updated summary:

**Subtotal:** \$1,180.00
**Discount (10%):** -\$118.00
**New Total:** \$1,062.00

Would you like me to add a note explaining the discount?"

***

### "Show me all overdue invoices"

**AI uses:** `query_invoices` with:

* `status`: "Overdue"

**AI responds:** "You have 3 overdue invoices totaling \$6,250.00:

1. **INV-1247** - ABC Corp - \$3,200.00 - Due January 5th (6 days overdue)
2. **INV-1239** - XYZ Industries - \$2,100.00 - Due December 28th (14 days overdue)
3. **INV-1235** - Smith Consulting - \$950.00 - Due December 15th (27 days overdue)

Would you like me to help you draft follow-up messages for any of these?"

***

### "Create an invoice for Ruth Smith for \$12,000 split into 3 monthly payments"

**AI uses:** `save_invoice` with:

* `customer`: "Ruth Smith"
* `lineItems`: (gathered from context or user clarification)
* `installments`:
  * amount: 4000, date: "2025-02-01"
  * amount: 4000, date: "2025-03-01"
  * amount: 4000, date: "2025-04-01"
* `date`: today's date
* `notes`: "Payment plan: 3 equal installments of \$4,000.00 due on the 1st of each month"

**AI responds:** "I've created INV-1254 for Ruth Smith with a \$12,000.00 payment plan:

**Payment Schedule:**

* Payment 1: \$4,000.00 due February 1, 2025
* Payment 2: \$4,000.00 due March 1, 2025
* Payment 3: \$4,000.00 due April 1, 2025

The invoice notes include the payment plan terms. What line items should I add to the invoice for the \$12,000.00 total?"


# Model Context Protocol
Source: https://docs.tight.com/ai/mcp-tools/mcp-overview

Integrate Tight accounting capabilities using Tight's Model Context Protocol (MCP) server

The Tight Model Context Protocol (MCP) server provides a set of tools that AI agents can use to interact with the Tight
API. You can use the MCP tools as a developer embedding Tight into your product, as a business owner looking for
financial insights, or as your platform seeking to perform comparative analytics across all businesses on your platform.

## Connect to Tight's MCP Server

### Connect as a bookkeeper or support agent

Configure your AI tool to point at the Tight MCP server using the parameters below. After you finish setup, your tool
walks you through the [OAuth flow](#authenticate-with-oauth) to sign in and grant access.

<Tabs>
  <Tab title="Claude">
    For Claude Pro, Max, Team, or Enterprise users, add Tight as a custom connector. To learn more, see the Claude
    [documentation](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp).

    In the Claude desktop or web app, go to **Settings** > **Connectors** > **Add custom connector** and use the
    following parameters:

    * **Remote MCP server URL**: `https://mcp.tight.com` for production or `https://mcp.sandbox.tight.com` for sandbox
    * **Connection mechanism**: OAuth
  </Tab>

  <Tab title="ChatGPT">
    For ChatGPT Pro, Plus, Business, Enterprise, or Education users, follow the
    [OpenAI documentation](https://platform.openai.com/docs/guides/developer-mode) for custom connectors using the
    following parameters:

    * **Server URL**: `https://mcp.tight.com` for production or `https://mcp.sandbox.tight.com` for sandbox
    * **Connection mechanism**: OAuth
  </Tab>
</Tabs>

### Connect as a developer

Register the Tight MCP server with your development tool using the configuration below. Once registered, your tool
prompts you through the [OAuth flow](#authenticate-with-oauth) to sign in and grant access.

<Tabs>
  <Tab title="Claude Code">
    Execute the following command to register the Tight MCP server. To learn more, see the Claude Code
    [documentation](https://docs.anthropic.com/en/docs/claude-code/mcp#configure-mcp-servers).

    <CodeGroup>
      ```bash Production theme={null}
      claude mcp add-json tight '{"type":"http","url":"https://mcp.tight.com/"}'
      ```

      ```bash Sandbox theme={null}
      claude mcp add-json tight '{"type":"http","url":"https://mcp.sandbox.tight.com/"}'
      ```
    </CodeGroup>
  </Tab>

  <Tab title="VS Code">
    Add the following to your `.vscode/mcp.json`. To learn more, see the VS
    Code [documentation](https://code.visualstudio.com/docs/copilot/chat/mcp-servers).

    <CodeGroup>
      ```json Production theme={null}
      {
        "servers": {
          "tight": {
            "type": "http",
            "url": "https://mcp.tight.com"
          }
        }
      }
      ```

      ```json Sandbox theme={null}
      {
        "servers": {
          "tight": {
            "type": "http",
            "url": "https://mcp.sandbox.tight.com"
          }
        }
      }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Custom Connectors">
    Use the remote server URL `https://mcp.tight.com` for production or `https://mcp.sandbox.tight.com` for sandbox,
    with an `accessToken` obtained via the Tight [Authentication Endpoint](/api-reference/authentication).

    <CodeGroup>
      ```json Production theme={null}
      {
        "mcpServers": {
          "tight": {
            "command": "npx",
            "args": [
              "mcp-remote",
              "https://mcp.tight.com",
              "--header",
              "Authorization:${AUTH_HEADER}"
            ],
            "env": {
              "AUTH_HEADER": "Bearer ${tight_access_token}"
            }
          }
        }
      }
      ```

      ```json Sandbox theme={null}
      {
        "mcpServers": {
          "tight": {
            "command": "npx",
            "args": [
              "mcp-remote",
              "https://mcp.sandbox.tight.com",
              "--header",
              "Authorization:${AUTH_HEADER}"
            ],
            "env": {
              "AUTH_HEADER": "Bearer ${tight_access_token}"
            }
          }
        }
      }
      ```
    </CodeGroup>
  </Tab>
</Tabs>

### Connect your existing AI chat interface

The Tight MCP server allows you to easily connect your product's existing AI chat interface by accepting the standard
Authorization header on any request.

Simply [generate an access token](/api-reference/authentication) and pass this on all requests to the Tight MCP server.

## Authenticate with OAuth

Once you attempt to connect, you are presented with a standard OAuth flow. Sign in with your email and password to
authenticate.

<img alt="Tight MCP OAuth login screen" />

<Tip>
  If you do not yet have a password, select the option to email yourself a link to set one, then return to the login
  screen to sign in.
</Tip>

After authenticating, you are asked to grant access. Choose the level of access to grant the connection:

* **Read-only**: The connection can view your data but cannot make changes.
* **Read and write**: The connection can both view your data and make changes on your behalf.

<img alt="Tight MCP consent screen for selecting read-only or read and write access" />

## Tools

Once connected, you can now interact with the Tight API using your AI tool of choice. The Tight MCP server exposes a
variety of [MCP tools](https://modelcontextprotocol.io/specification/2025-06-18/server/tools) grouped by domain area.
Review the specific tools for each below:

* [Bank Transactions](/ai/mcp-tools/bank-transactions-mcp)
* [Embedding & Integration](/ai/mcp-tools/embedding-and-integration-mcp)
* [Financial Statements](/ai/mcp-tools/financial-statements-mcp)
* [Invoicing](/ai/mcp-tools/invoicing-mcp)


# AI-Native GL
Source: https://docs.tight.com/ai/philosophy/ai-native-general-ledger

Leveraging data from over 1.3M SMBs and a fully deterministic General Ledger

## Best of everything AI-native GL (AGL)

A fully deterministic general ledger ensures accuracy and reliability, but traditional ledgers weren't built to
take full advantage of AI. Tight built its AI-native General Ledger to both take advantage of the quick evolution of
LLMs and leverage the accuracy of a fully deterministic ledger.

### What AI can automate

AI helps automate categorization (93% on average), reconciliation, anomaly detection, reporting, and analysis, while the
fully deterministic nature of Tight's GL ensures AI hallucinations don't impact the underlying GL.

### Why a deterministic General Ledger

By nature of their model, LLMs work best with human language-level abstractions, not writing debits and credits
directly into the GL. Tight's API provides these LLM-friendly abstractions, e.g. categorizing a transaction, marking a
bill as paid, refunding an invoice payment, while encapsulating the underlying writes into the GL in a proven, robust
architecture. This API-first design is the *perfect* use case for Agents to fully manage a user's books without needing
to manage low-level general ledger transactions directly.

## Agentic Accounting

Agentic Accountants have arrived, allowing business owners to keep their books on auto-drive while trusting that Agentic
Accountants will reach out with any questions if/when needed. See
Tight's [Agentic Accounting updates](/ai/agentic/agentic-accountant) to stay up to date on its rapid
evolution.

## Creating an AI-native architecture

Tight's most talented (both experienced and AI-native) engineers reenvisioned Tight's APIs and architecture with Agentic
Accountants in mind, yielding Tight's AI-native ledger:

* [v6 API](/api-reference/authentication)
  * Proven maturity and edge-case handling from v5
  * DB optimized for high-performance floor and ceiling for AI-centric use cases, including burst requests
  * Result sets formatted for ease of consumption by LLMs
* [Self-learning transaction categorization and reconciliation](ai/categorization/self-learning-transaction-categorization-overview),
  leveraging rules formed by 1.3M SMBs' worth of data

## Building Tight MCPs

The [Tight MCP Server](/ai/mcp-tools/mcp-overview) was designed in parallel with the Tight v6 API itself, naturally
creating a cohesive AI-native ecosystem. That combined with the Tight team's deep knowledge of accounting use-cases,
both for business owners and bookkeepers, translated to a comprehensive set of MCP tools enabling agentic interaction
with the Tight API.

The Tight API's MCP tools are grouped by domain area:

* [Bank Transactions](/ai/mcp-tools/bank-transactions-mcp)
* [Embedding & Integration](/ai/mcp-tools/embedding-and-integration-mcp)
* [Financial Statements](/ai/mcp-tools/financial-statements-mcp)
* [Invoicing](/ai/mcp-tools/invoicing-mcp)

## Next Steps

<CardGroup>
  <Card title="MCP Tools" icon="rocket-launch" href="/ai/mcp-tools/mcp-overview">
    Integrate Tight's rich accounting knowledge into your LLM-powered product
  </Card>

  <Card title="Agentic Accounting" icon="sparkles" href="/guides/launch-paths/embed-in-your-ux">
    Enable autonomous AI agents to handle end-to-end accounting workflows
  </Card>
</CardGroup>


# Chart of Accounts
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/accounting/chart-of-accounts

Manage a business's chart of accounts and GL account structure

## Overview

The Chart of Accounts provides a real-time, hierarchical drill-down balance sheet, allowing business owner-operators and bookkeepers to:

* View their GL Account structure
* Add/edit GL Accounts
* View a real-time balance sheet
* Set beginning balances

<img alt="Chart of Accounts Demo" />

## Embedding the Chart of Accounts

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the Chart of Accounts:

```javascript theme={null}
Tight.render(containerId, "ChartOfAccounts");
```


# General Ledger
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/accounting/general-ledger

View and manage a business's general ledger entries

## Overview

The General Ledger provides a GL account-specific view into accounting transactions, allowing business owner-operators and bookkeepers to:

* View transactions specific to a given GL account
* See running debits/credits and how each transaction impacts the balance for the given GL account
* Edit transactions
* Download GL data into a spreadsheet

<img alt="General Ledger Demo" />

## Embedding the General Ledger

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the General Ledger:

```javascript theme={null}
Tight.render(containerId, "GeneralLedger");
```


# Journal
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/accounting/journal

Create and manage journal entries for a business

## Overview

The Journal displays running debits and credits for all accounting transactions. While business owner-operators don't typically access this view, it allows bookkeepers to:

* Review debits/credits in manner that bookkeepers are used to
* Add manual journal entries, which can be required in extreme edge cases
* View a Trial Balance report

<img alt="Journal Demo" />

## Embedding the Journal

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the Journal:

```javascript theme={null}
Tight.render(containerId, "Journal");
```


# Expense Dashboard
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/bank-transactions/expense-dashboard

Track and tag expenses, directly in your existing web app

## Overview

The Expense Dashboard allows you to embed fully-featured expense tracking into your existing web app, including:

* Automatic expense tracking, including [expense categorization and self-learning rules](/ai/categorization/self-learning-transaction-categorization-overview)
* Fully encapsulated bank account and credit card linkage, using [Plaid](/integrations/banking/plaid)
* User experience allowing your users to:
  * manage bank account connections
  * view expense reports (eg. by category, by vendor)
  * attach receipts to expenses
  * split expenses across categories

<img alt="Expense Dashboard Demo" />

## Embedding the Expense Dashboard

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the Expense Dashboard:

```javascript theme={null}
Tight.render(containerId, "ExpenseDashboard");
```


# Income Dashboard
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/bank-transactions/income-dashboard

The fully-featured experience for viewing and managing income

## Overview

The Income Dashboard is all you need to provide full insight into business income to your users, with a full user
experience allowing your users to:

* Link bank accounts and credit cards
* See how Tight AI categorized transactions
* Review any transactions that Tight AI could not confidently categorize
* Drill into payouts, to understand which invoices, merchant fees, and other line items comprise a payout
* Visualize income over time
* View/filter/search for income

<img alt="Income Dashboard Demo" />

## Embedding the Income Dashboard

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the Income Dashboard:

```javascript theme={null}
Tight.render(containerId, "IncomeDashboard");
```


# Transactions Dashboard
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/bank-transactions/transactions-dashboard

The fully-featured experience for viewing and managing bank transactions

## Overview

The Transactions Dashboard is all you need to provide full transaction classification to your users, with a full user experience allowing your users to:

* Link bank accounts and credit cards
* See how transactions were segmented between revenue, expenses, refunds, bank transfers, and tax payments
* Drill into payouts, to understand which invoices, merchant fees, and other line items comprise a payout
* Review any transactions that Tight AI could not confidently categorize
* View/filter/search for transactions

<img alt="Transaction Dashboard Demo" />

## Embedding the Transactions Dashboard

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the Transactions Dashboard:

```javascript theme={null}
Tight.render(containerId, "TransactionsDashboard");
```


# Banks & Integrations
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/banks-and-integrations

Comprehensive standalone management for a user’s financial accounts

## Overview

The Banks & Integrations page gives users a clear and intuitive way to manage all of their financial accounts, including:

* Linking bank accounts through native integrations (e.g. Plaid)
* Creating and maintaining manual accounts
* Managing beginning balances across all account types
* Editing start dates for linked accounts
* Addressing connection or credential issues
* Cleaning up accounts through guided merge tools

## Embedding Banks & Integrations

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the Banks & Integrations page:

```javascript theme={null}
Tight.render(containerId, "BanksAndIntegrations");
```


# Bookkeeper Dashboard
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/bookkeeper-dashboard

Manage the books for all the businesses on your Virtual Bookkeeping platform

## Overview

Tight's Virtual Bookkeeping platform allows you to enable your own virtual bookkeeping business or embedded accounting
features within days, with QuickBooks-like functionality, but with significantly increased efficiency for your
bookkeeping team. Tight’s proven platform is used by thousands of accountants, virtual bookkeepers, tax preparers and
Fintech platforms to efficiently service hundreds of thousands of small business clients.

From the Accountant Dashboard, bookkeepers can easily manage bookkeeping teammates (including granular permissions), add
new clients, perform bank reconciliations, generate/email reports, and securely log into their clients' accounts.

<img alt="Bookkeeper Dashboard Demo" />

<V5OnlyWarning href="/v5.0/embeddable-ui/bookkeepers/bookkeeper-dashboard" />

## Embedding the Bookkeeper Dashboard

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions
on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the Bookkeeper Dashboard:

```javascript theme={null}
Tight.render(containerId, "AccountantDashboard");
```


# Financial Overview
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/financial-overview

An intelligent overview of the business owner's monthly financials

## Overview

The Financial Overview is all you need to provide full financials to your users, including:

* Onboarding-related action items like linking bank accounts and credit cards
* Monthly financial summaries
* As-needed action items whenever the business owner's attention is needed (e.g. the purpose of a bank transaction is unknown)
* Access to financial reporting (e.g. Profit & Loss, Balance Sheet, etc.)

<img alt="Financial Overview Demo" />

## Embedding the Financial Overview

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the Financial Overview:

```javascript theme={null}
Tight.render(containerId, "FinancialOverview");
```


# Report Dashboard
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/financial-statements/report-dashboard

Access and manage all your business's financial reports

## Overview

Tight's Report Dashboard is a full-featured embedded experience (including all drill-down rows) for everything related to reports; all you need to do is add a "Reports" item to your product's navigation.

<img alt="Report Dashboard Demo" />

## Embedding the Report Dashboard

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the Report Dashboard:

```javascript theme={null}
Tight.render(containerId, "ReportDashboard");
```

## Options

<Warning>
  Selecting and reordering the list of reports is currently only available in the [v5 Javascript SDK](/v5.0/embeddable-ui/financial-statements/report-dashboard).
  It will be available in the v6 Plain JS SDK soon.
</Warning>

Until then, the Report Dashboard displays the full set of reports the business is entitled to, broken into sections.


# Design
Source: https://docs.tight.com/embeddable-ui/plain-js/patterns/design

Tight customizes the Embedded UI to match your product's look and feel

## Get Started

<Tip>Every Tight Page supports desktop web, mobile web, and all breakpoints in between</Tip>
Tight will work with you to understand your design needs and ensure the Embedded UI matches your brand. To begin, share
one of the following:

* **Your application**: A login URL and credentials that Tight's design team can use to analyze your branding and
  styling
* **Design materials**: Brand guidelines, Figma files, or other design documentation

## Initial Setup

Tight's design team will need 2 to 4 weeks to complete the deep white labeling. Your team can add the Embedded
experience into your product in parallel with the Tight team customizing the look and feel to match your product. Once
the Tight team has completed the custom design implementation, the customized look and feel will automatically be
associated with your Tight API `client_id` and show up in your Embedded experience.

## Iterating Your Styles

You can submit a support request for design changes to Tight, and Tight will iterate the styling to ensure the
accounting functionality is embedded into your product in such a way that your users would never know it wasn't built
in-house.


# Embedding
Source: https://docs.tight.com/embeddable-ui/plain-js/patterns/embedding

Get started with Tight Embeddable UI via the plain Javascript SDK

The Tight Javascript SDK lets you embed Tight pages directly into your web app with no build step and no framework
dependency. Load the script, initialize it with an access token, and render a page into an element you already have in
your DOM.

<Tip>Every Tight page supports desktop web, mobile web, and all breakpoints in between.</Tip>

## Get Started

<Steps>
  <Step title="Load the SDK">
    Add `tight.js` to your page with a `<script>` tag:

    ```html theme={null}
    <script src="https://cdn.sandbox.tight.com/embedded/latest/tight.js"></script>
    ```

    Swap in the production URL when you're ready to go live. See [Environments](#environments).
  </Step>

  <Step title="Initialize with an access token">
    ```javascript theme={null}
    Tight.init(accessToken);
    ```
  </Step>

  <Step title="Render a page">
    ```javascript theme={null}
    Tight.render("finance-dashboard", "FinancialOverview");
    ```
  </Step>
</Steps>

## Loading the SDK

Loading the script creates a single global instance at `window.Tight`. Load it only once per page: a second load logs
an error and has no effect.

<Tip>
  For convenience, assign `window.Tight` to a local variable and use that for subsequent calls:

  ```javascript theme={null}
  const Tight = window.Tight;
  ```
</Tip>

### Environments

The script URL selects which Tight API environment the SDK targets:

| Environment | Script URL |
| - | - |
| Sandbox | `https://cdn.sandbox.tight.com/embedded/latest/tight.js` |
| Production | `https://cdn.prod.tight.com/embedded/latest/tight.js` |

Load the URL for the environment you'd like to target, and use an `accessToken` issued for that same environment. You
can obtain an applicable `accessToken` via the Tight [Authentication Endpoint](/api-reference/authentication).

<Tip>Examples on this page use the sandbox URL. Swap in the production URL when you're ready to launch.</Tip>

## Initializing the SDK

Call `init` with an access token before rendering anything. This authenticates the SDK and resets it to a clean state,
removing any existing page and listeners.

```javascript theme={null}
Tight.init(accessToken);
```

| Parameter | Type | Description |
| - | - | - |
| `accessToken` | `string` | A valid access token for the current user. Obtain one via the Tight [Authentication Endpoint](/api-reference/authentication). |

`init` does not render a page by itself. Call `render` afterward to display content.

### Refreshing credentials

Access tokens expire after 3600 seconds. When your token expires or changes, call `auth` instead of `init`. It updates
the token in place without clearing an already-rendered page or your registered listeners.

```javascript theme={null}
Tight.auth(newAccessToken);
```

<Warning>
  Calling `init` again to refresh a token tears down the rendered page and every registered listener. Use `auth` for
  token rotation and reserve `init` for first-time setup or switching users.
</Warning>

## Rendering a page

Call `render` to display a page inside a container element in your document.

```javascript theme={null}
Tight.render(containerId, page);
```

| Parameter | Type | Description |
| - | - | - |
| `containerId` | `string` | The `id` of an element already present in your DOM. The page renders inside this element. |
| `page` | `string` | The page to display. See [supported page values](#supported-page-values). |

```html theme={null}
<div id="finance-dashboard"></div>
<script>
    Tight.render("finance-dashboard", "FinancialOverview");
</script>
```

Calling `render` again with a different `page` value updates the displayed page. Calling it with a different
`containerId` moves the page to that container.

### Supported page values

| Value | Page |
| - | - |
| `FinancialOverview` | [Financial Overview](/embeddable-ui/plain-js/pages/financial-overview) |
| `TransactionsDashboard` | [Transactions Dashboard](/embeddable-ui/plain-js/pages/bank-transactions/transactions-dashboard) |
| `BanksAndIntegrations` | [Banks & Integrations](/embeddable-ui/plain-js/pages/banks-and-integrations) |
| `ExpenseDashboard` | [Expense Dashboard](/embeddable-ui/plain-js/pages/bank-transactions/expense-dashboard) |
| `IncomeDashboard` | [Income Dashboard](/embeddable-ui/plain-js/pages/bank-transactions/income-dashboard) |
| `ReportDashboard` | [Report Dashboard](/embeddable-ui/plain-js/pages/financial-statements/report-dashboard) |
| `GeneralLedger` | [General Ledger](/embeddable-ui/plain-js/pages/accounting/general-ledger) |
| `ChartOfAccounts` | [Chart of Accounts](/embeddable-ui/plain-js/pages/accounting/chart-of-accounts) |
| `Journal` | [Journal](/embeddable-ui/plain-js/pages/accounting/journal) |

## Listening for events

Use `registerListener` to react to actions that happen inside the rendered page, such as a form opening or a workflow
completing. You might route a user back to your own invoicing product, gate functionality behind your own paywall, or
send analytics when a user opens a dashboard tile.

```javascript theme={null}
Tight.registerListener(key, listener, options);
```

| Parameter | Type | Description |
| - | - | - |
| `key` | `string` | The event to subscribe to. See [supported event keys](#supported-event-keys). |
| `listener` | `(payload: unknown) => void` | Callback invoked when the event fires. |
| `options.preventDefault` | `boolean` (optional) | When `true`, suppresses the SDK's default UI behavior for that event while still notifying your listener. Defaults to `false`. |

```javascript theme={null}
Tight.registerListener("invoice", (payload) => {
    console.log("Invoice event:", payload);
});
```

To stop listening, call `unregisterListener` with the same key:

```javascript theme={null}
Tight.unregisterListener("invoice");
```

### Supported event keys

| Key | Fires on |
| - | - |
| `plaidLink` | Bank account linking actions (new, reset, relink, unlink, route to bank) |
| `plaidLinkEvent` | Raw bank-linking flow telemetry |
| `plaidLinkError` | Bank-linking failure |
| `gusto` | Gusto payroll connection started |
| `payroll` | Payroll record opened |
| `bITile` | A dashboard tile (cash flow, expense, profit & loss) is opened |
| `conversations` | A conversation/thread is opened |
| `bill` | A bill is opened |
| `invoice` | An invoice form is opened |
| `revenueRecognition` | A revenue recognition record is opened |
| `expenseAmortization` | An expense amortization record is opened |
| `assetDepreciation` | An asset depreciation record is opened |
| `journalEntry` | A journal entry is opened |
| `transactionForm` | Any transaction form is opened or closed (bank or processor) |
| `bankTransactionForm` | A bank transaction form is opened or closed |
| `processorTransactionForm` | A processor transaction form is opened or closed |
| `customer` | A customer record is opened |

Each listener receives a payload describing the result of the action, including whether it succeeded and any associated
data or error details.

## Full example

```html theme={null}
<div id="finance-dashboard" style="width: 100%; height: 800px;"></div>

<script src="https://cdn.sandbox.tight.com/embedded/latest/tight.js"></script>
<script>
    const Tight = window.Tight;
    Tight.init(accessToken);

    Tight.registerListener("invoice", (payload) => {
        console.log("Invoice event:", payload);
    });

    Tight.render("finance-dashboard", "FinancialOverview");
</script>
```


# Expense Dashboard
Source: https://docs.tight.com/embeddable-ui/react-native/expense-dashboard

Track and tag expenses, directly in your existing mobile app

## Overview

The React Native Expense Dashboard Component allows you to embed fully-featured expense tracking into your existing React Native mobile app, including:

* Automatic expense tracking, including [expense categorization and self-learning rules](/ai/categorization/self-learning-transaction-categorization-overview)
* Fully encapsulated bank account and credit card linkage, using [Plaid](/integrations/banking/plaid)
* User experience allowing your users to:
  * manage bank account connections
  * view expense reports (eg. by category, by vendor)
  * attach receipts to expenses
  * split expenses across categories

## UX

<Warning>
  This page is under construction. Please check back later for more content.
</Warning>

## Embedding the Expense Dashboard

To initialize the Tight Embedded experience in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react-native/patterns/embedding).

Below is an example embedding of the Expense Dashboard:

```TSX ExpenseScreen.tsx theme={null}
import { ExpenseDashboard, Tight } from "@tight-embedded/react-native";

function ExpenseScreen({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <ExpenseDashboard />
      </Tight>
    )
}
```


# Mileage Dashboard
Source: https://docs.tight.com/embeddable-ui/react-native/mileage-dashboard

Automatically track mileage, directly in your existing mobile app

<Tip>The Tight Mileage SDK tracks 1M+ miles per days and over 1B miles-to-date</Tip>

## Overview

The React Native Mileage Dashboard Component allows you to embed fully-featured [mileage tracking](/guides/business-owners/mileage-tracking) into your existing React Native mobile app, including:

* Auto-start / auto-stop mileage tracking that detects whether the user is driving using advanced telemetrics (GPS, Geofencing, etc.)
* Fully encapsulated permissioning and ability to run in the background, without your team having to learn anything about native iOS/Android permissioning
* User experience allowing your users to:
  * View drives/routes/addresses
  * Swipe to classify drive purpose (business vs. personal)
  * Define favorite locations
  * Link their vehicle's bluetooth device
* Location learning (e.g. automatically classifying drives to client locations as business)
* iOS and Android support, including annual updates around new OS releases

## UX

<Warning>
  This page is under construction. Please check back later for more content.
</Warning>

## Embedding the Mileage Dashboard

To initialize the Tight Embedded experience in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react-native/patterns/embedding).

Below is an example embedding of the Mileage Dashboard:

```TSX MileageScreen.tsx theme={null}
import { MileageDashboard, Tight } from "@tight-embedded/react-native";

function MileageScreen({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <MileageDashboard />
      </Tight>
    )
}
```


# Embedding
Source: https://docs.tight.com/embeddable-ui/react-native/patterns/embedding

Get started with Tight Embeddable UI for React Native

## Get Started

### NPM Configuration

Each Page is shipped in Tight's React Native Component Library, which can be installed as follows:

<CodeGroup>
  ```bash npm theme={null}
  npm install @tight-embedded/react-native@latest
  ```
</CodeGroup>

Once imported, you'll need to ensure that every Embeddable UI component is rendered in a React Tree
wrapped with a `<Tight>` component.

```TSX MileageScreen.tsx theme={null}
import { MileageDashboard, Tight } from "@tight-embedded/react-native";

function MileageScreen({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <MileageDashboard />
      </Tight>
    )
}
```

Tight recommends adding a single `<Tight>` component towards the top of your application tree for maintainability.
The `<Tight>` component's `environment` property can be `"PRODUCTION"` or `"SANDBOX"`, depending on the environment you'd like to target. You can obtain an applicable `accessToken` via the Tight [Authentication Endpoint](/api-reference/authentication).

In addition to installing the Tight React Native Component Library, you must add the following to your `package.json`

```json package.json theme={null}
{
    ...
    "react": "18.2.0",
    "react-native": "0.75.5",
    "react-redux": "~6.0.0",
    "redux": "~4.0.0",
    "@react-native-async-storage/async-storage": "~1.22.3",
    "@react-native-community/datetimepicker": "~7.6.3",
    "@react-native-community/netinfo": "~6.0.6",
    "@react-native-cookies/cookies": "6.2.1",
    "@react-native-picker/picker": "~2.7.2",
    "react-native-device-info": "~8.4.5",
    "react-native-gesture-handler": "~2.20.0",
    "react-native-reanimated": "~3.18.0",
    "react-native-localize": "github:tight-embedded/react-native-localize#v1.4.0-patch-1",
    "react-native-safe-area-context": "~4.10.0",
    "react-native-screens": "~3.33.0",
    "react-native-maps": "~1.13.2",
    "rn-fetch-blob": "github:tight-embedded/rn-fetch-blob#v0.11.2-patch-5"
    ...
}
```

### Babel Configuration

You must also add `react-native-reanimated/plugin` as the last plugin in your `babel.config.js`

```javascript babel.config.js theme={null}
module.exports = {
  ...
  plugins: [
    ...
    "react-native-reanimated/plugin"
  ],
  ...
};
```

### iOS Configuration

The Tight SDK supports a minimum iOS deployment version of iOS 17.0. Your app must target an iOS version greater than or equal to this version in order to use the Tight SDK.

#### Podfile Configuration

Add the following dependencies to your `Podfile`:

```ruby Podfile theme={null}
pod 'TightReactNative', :path => '../node_modules/@tight-embedded/react-native'
pod 'RNCAsyncStorage', :path => '../node_modules/@react-native-async-storage/async-storage', :modular_headers => true
pod 'GoogleUtilities', :modular_headers => true
pod 'GoogleMaps', '~> 7.3.0'
pod 'GooglePlaces', '~> 7.3.0'
```

#### Info.plist Configuration

In addition to installing the package with CocoaPods, you must also add the following to your app's `Info.plist` file:

1. The provided Tight API client id

```XML Info.plist theme={null}
<key>TightClientId</key>
<string>fake_client_id</string>
```

2. A Google Maps API key

```XML Info.plist theme={null}
<key>GoogleAPIKey</key>
<string>fake_google_api_key</string>
```

3. The following permission declarations, so that your app can request the necessary permissions from the user when they turn on mileage tracking, while complying with Apple's guidelines:

```XML Info.plist theme={null}
<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>YOUR_APP_NAME uses Tight to collect and transmit location data, which is used solely for drive detection and mileage tracking.

For automatic drive detection and mileage tracking, please select "Change to Always Allow".</string>

<key>NSLocationAlwaysUsageDescription</key>
<string>YOUR_APP_NAME uses Tight to collect and transmit location data, which is used solely for drive detection and mileage tracking.

For automatic drive detection and mileage tracking, please select "Change to Always Allow".</string>

<key>NSLocationUsageDescription</key>
<string>YOUR_APP_NAME uses Tight to collect and transmit location data, which is used solely for drive detection and mileage tracking.

For automatic drive detection and mileage tracking, please select "Allow While Using App".
</string>

<key>NSLocationWhenInUseUsageDescription</key>
<string>YOUR_APP_NAME uses Tight to collect and transmit location data, which is used solely for drive detection and mileage tracking.

For automatic drive detection and mileage tracking, please select "Allow While Using App".</string>

<key>NSMotionUsageDescription</key>
<string>YOUR_APP_NAME uses Tight to collect and transmit motion data, which is used solely for drive detection and mileage tracking.

For automatic drive detection and mileage tracking, please select “Allow”.
</string>

<key>UIBackgroundModes</key>
<array>
    <string>location</string>
</array>
```

### Android Configuration

The Tight SDK supports a minimum Android SDK version of 28. Your app must target an Android SDK version greater than or equal to this version in order to use the Tight SDK.

#### Gradle Configuration

Add the following to your `settings.gradle.kts` file:

```kotlin settings.gradle.kts theme={null}
pluginManagement {
    repositories {
        mavenCentral()
    }
}
```

Then, add the following to your `ReactApplication`:

```kotlin MainApplication.kt theme={null}
...
import com.tight.reactnative.Tight
...
class MainApplication : Application(), ReactApplication {
    ...
    override fun onCreate() {
        super.onCreate()
        Tight.initialize(this);
    }
    ...
}
```

#### Resource Configuration

In addition to the configuration above, you must also add the following to your app's resource files:

1. The provided Tight API client id in `res/values/strings.xml`

```XML strings.xml theme={null}
    <string name="tight_client_id">fake_client_id</string>
```

2. A Google Maps API key in `res/values/strings.xml`

```XML strings.xml theme={null}
    <string name="google_api_key_places">fake_google_api_key</string>
```


# Chart of Accounts
Source: https://docs.tight.com/embeddable-ui/react/accounting/chart-of-accounts

Manage a business's chart of accounts and GL account structure

## Overview

The Chart of Accounts provides a real-time, hierarchical drill-down balance sheet, allowing business owner-operators and bookkeepers to:

* View their GL Account structure
* Add/edit GL Accounts
* View a real-time balance sheet
* Set beginning balances

## Embedding the Chart of Accounts

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Chart of Accounts:

```TSX COA.tsx theme={null}
import { ChartOfAccounts, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function COA({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <ChartOfAccounts />
      </Tight>
    )
}
```


# General Ledger
Source: https://docs.tight.com/embeddable-ui/react/accounting/general-ledger

View and manage a business's general ledger entries

## Overview

The General Ledger provides a GL account-specific view into accounting transactions, allowing business owner-operators and bookkeepers to:

* View transactions specific to a given GL account
* See running debits/credits and how each transaction impacts the balance for the given GL account
* Edit transactions
* Download GL data into a spreadsheet

## Embedding the General Ledger

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the General Ledger:

```TSX Ledger.tsx theme={null}
import { GeneralLedger, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function Ledger({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <GeneralLedger />
      </Tight>
    )
}
```

## Props

<ParamField type={"object"}>
  The set of filters to apply to the dashboard.

  Passing in a value for this prop turns this into a controlled component. As such, you must also pass the
  `onChangeFilters` prop to adjust the filters for user input.

  <Expandable title={"filters"}>
    <ParamField type={"string"}>
      The ID for the GL Account to view on the General Ledger
    </ParamField>

    <ParamField>
      Category filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all entities with the following attachments.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Dimension value filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all entities with the following attachments.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      <Expandable title={"child attributes"}>
        <ParamField type={"string"}>
          Value - returns all records with specified field equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field not equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field greater than to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field greater than or equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field less than to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field less than or equal to this value.
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Review status filter

      <Expandable title={"child attributes"}>
        <ParamField type={"string[]"}>
          List of values to include.

          Available options: `RECONCILIATION_DISCREPANCY`, `USER_REVIEW_REQUIRED`, `ACCOUNTANT_REVIEW_REQUIRED`,
          `PARTNER_REVIEW_REQUIRED`, `AWAITING_MATCH`, `STAGED`, `RECONCILED`
        </ParamField>

        <ParamField type={"string[]"}>
          List of values to exclude.

          Available options: `RECONCILIATION_DISCREPANCY`,
          `USER_REVIEW_REQUIRED`,
          `ACCOUNTANT_REVIEW_REQUIRED`,
          `PARTNER_REVIEW_REQUIRED`,
          `AWAITING_MATCH`,
          `STAGED`,
          `RECONCILED`
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Type filter

      <Expandable title={"child attributes"}>
        <ParamField type={"string[]"}>
          List of values to include.

          Available options: `EXPENSE`,
          `REVENUE`,
          `BANK_TRANSFER`,
          `TAX_PAYMENT`,
          `INVOICE_PAYMENT`
        </ParamField>

        <ParamField type={"string[]"}>
          List of values to exclude.

          Available options: `EXPENSE`,
          `REVENUE`,
          `BANK_TRANSFER`,
          `TAX_PAYMENT`,
          `INVOICE_PAYMENT`
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the filters from the dashboard.
  This function will only be invoked if the `filters` prop is also provided. The callback takes `filters` as its single
  argument.
</ParamField>

<ParamField type={"number"}>
  The number of transactions to show on a single page of the Transactions Dashboard.
</ParamField>


# Journal
Source: https://docs.tight.com/embeddable-ui/react/accounting/journal

Create and manage journal entries for a business

## Overview

The Journal displays running debits and credits for all accounting transactions. While business owner-operators don't typically access this view, it allows bookkeepers to:

* Review debits/credits in manner that bookkeepers are used to
* Add manual journal entries, which can be required in extreme edge cases
* View a Trial Balance report

## Embedding the Journal

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Journal:

```TSX JournalDash.tsx theme={null}
import { Journal, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function JournalDash({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <Journal />
      </Tight>
    )
}
```

## Props

<ParamField type={"object"}>
  The set of filters to apply to the dashboard.

  Passing in a value for this prop turns this into a controlled component. As such, you must also pass the
  `onChangeFilters` prop to adjust the filters for user input.

  <Expandable title={"filters"}>
    <ParamField>
      General ledger account filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all entities with the following attachments.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Dimension value filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all entities with the following attachments.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      <Expandable title={"child attributes"}>
        <ParamField type={"string"}>
          Value - returns all records with specified field equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field not equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field greater than to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field greater than or equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field less than to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field less than or equal to this value.
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the filters from the dashboard.
  This function will only be invoked if the `filters` prop is also provided. The callback takes `filters` as its single
  argument.
</ParamField>

<ParamField type={"number"}>
  The number of transactions to show on a single page of the Transactions Dashboard.
</ParamField>


# Expense Dashboard
Source: https://docs.tight.com/embeddable-ui/react/bank-transactions/expense-dashboard

The fully-featured experience for viewing and managing expenses

## Overview

The Expense Dashboard is all you need to provide full insight into business expenses to your users, allowing your users to:

* Link bank accounts and credit cards
* See how Tight AI categorized transactions
* Review any transactions that Tight AI could not confidently categorize
* Visualize expenses over time
* View/filter/search for expenses

<img alt="Expense Dashboard Demo" />

<img alt="Mobile Expense Dashboard Demo" />

## Embedding the Transactions Dashboard

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Expense Dashboard:

```TSX TransactionsDashboard.tsx theme={null}
import { ExpenseDashboard, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function ExpenseDash({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <ExpenseDashboard />
      </Tight>
    )
}
```

## Props

<ParamField type={"Array<{ column: string; width?: number }>"}>
  An ordered array describing which table columns to display on the dashboard. Duplicate entries will
  be ignored.

  A column is an object with two fields, `column` and `width`.
  `column` is the name of the column. `width` is the desired pixel width of the column, and is optional.

  Available options: `date`, `description`, `amount`, `category`, `reviewStatus`, `dimensionValue`
</ParamField>

<ParamField type={"object"}>
  The set of filters to apply to the dashboard.

  Passing in a value for this prop turns this into a controlled component. As such, you must also pass the
  `onChangeFilters` prop to adjust the filters for user input.

  <Expandable title={"filters"}>
    <ParamField>
      Category filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all expenses in the given categories.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Dimension value filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all expenses belonging to the given dimension values.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      <Expandable title={"child attributes"}>
        <ParamField type={"string"}>
          Value - returns all expenses on the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all expenses not on the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all expenses after the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all expenses on or after the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all expenses before the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all expenses on or before the given date.
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Review status filter

      <Expandable title={"child attributes"}>
        <ParamField type={"string[]"}>
          List of values to include.

          Available options: `RECONCILIATION_DISCREPANCY`, `USER_REVIEW_REQUIRED`, `ACCOUNTANT_REVIEW_REQUIRED`,
          `PARTNER_REVIEW_REQUIRED`, `AWAITING_MATCH`, `STAGED`, `RECONCILED`
        </ParamField>

        <ParamField type={"string[]"}>
          List of values to exclude.

          Available options: `RECONCILIATION_DISCREPANCY`,
          `USER_REVIEW_REQUIRED`,
          `ACCOUNTANT_REVIEW_REQUIRED`,
          `PARTNER_REVIEW_REQUIRED`,
          `AWAITING_MATCH`,
          `STAGED`,
          `RECONCILED`
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the filters from the dashboard.
  This function will only be invoked if the `filters` prop is also provided. The callback takes `filters` as its single
  argument.
</ParamField>

<ParamField type={"number"}>
  The number of transactions to show on a single page of the Transactions Dashboard.
</ParamField>


# Income Dashboard
Source: https://docs.tight.com/embeddable-ui/react/bank-transactions/income-dashboard

The fully-featured experience for viewing and managing income

## Overview

The Income Dashboard is all you need to provide full insight into business income to your users, allowing your users to:

* Link bank accounts and credit cards
* See how Tight AI categorized transactions
* Review any transactions that Tight AI could not confidently categorize
* Drill into payouts, to understand which invoices, merchant fees, and other line items comprise a payout
* Visualize income over time
* View/filter/search for income

<img alt="Income Dashboard Demo" />

<img alt="Mobile Income Dashboard Demo" />

## Embedding the Transactions Dashboard

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Income Dashboard:

```TSX IncomeDashboard.tsx theme={null}
import { IncomeDashboard, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function IncomeDash({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <IncomeDashboard />
      </Tight>
    )
}
```

## Props

<ParamField type={"Array<{ column: string; width?: number }>"}>
  An ordered array describing which table columns to display on the dashboard. Duplicate entries will
  be ignored.

  A column is an object with two fields, `column` and `width`.
  `column` is the name of the column. `width` is the desired pixel width of the column, and is optional.

  Available options: `date`, `description`, `amount`, `category`, `reviewStatus`, `dimensionValue`
</ParamField>

<ParamField type={"object"}>
  The set of filters to apply to the dashboard.

  Passing in a value for this prop turns this into a controlled component. As such, you must also pass the
  `onChangeFilters` prop to adjust the filters for user input.

  <Expandable title={"filters"}>
    <ParamField>
      Category filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all incomes in the given categories.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Dimension value filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all incomes belonging to the given dimension values.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      <Expandable title={"child attributes"}>
        <ParamField type={"string"}>
          Value - returns all incomes on the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all incomes not on the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all incomes after the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all incomes on or after the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all incomes before the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all incomes on or before the given date.
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Review status filter

      <Expandable title={"child attributes"}>
        <ParamField type={"string[]"}>
          List of values to include.

          Available options: `RECONCILIATION_DISCREPANCY`, `USER_REVIEW_REQUIRED`, `ACCOUNTANT_REVIEW_REQUIRED`,
          `PARTNER_REVIEW_REQUIRED`, `AWAITING_MATCH`, `STAGED`, `RECONCILED`
        </ParamField>

        <ParamField type={"string[]"}>
          List of values to exclude.

          Available options: `RECONCILIATION_DISCREPANCY`,
          `USER_REVIEW_REQUIRED`,
          `ACCOUNTANT_REVIEW_REQUIRED`,
          `PARTNER_REVIEW_REQUIRED`,
          `AWAITING_MATCH`,
          `STAGED`,
          `RECONCILED`
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the filters from the dashboard.
  This function will only be invoked if the `filters` prop is also provided. The callback takes `filters` as its single
  argument.
</ParamField>

<ParamField type={"number"}>
  The number of transactions to show on a single page of the Transactions Dashboard.
</ParamField>


# Transaction Form
Source: https://docs.tight.com/embeddable-ui/react/bank-transactions/transaction-form

Create and edit individual bank transactions

## Overview

Tight's Transaction Form Embedded experience makes it easy for you to direct a user or accountant to a specific transaction for review. This serves as a simple way to have your users or their accountant interact with and update their transactions in the Tight API.

## Embedding the Transaction Form

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Transaction Form:

```TSX Form.tsx theme={null}
import { TransactionForm, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function Form({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <TransactionForm id={"btxn_12345"} />
      </Tight>
    )
}
```

## Props

<ParamField type={"string"}>
  The `bankTransaction.id` that belongs to the form you would like to render. The form will automatically render
  the correct fields for the bank transaction.
</ParamField>

<ParamField type={"function"}>
  The `onClose` function is called anytime the user closes the form.
  This indicates that the `<TransactionForm>` can safely be removed from the component tree.

  <Expandable title={"arguments"}>
    <ParamField type={"object"}>
      The result of a successful form submission. Empty when the `error` argument is non-null.
    </ParamField>

    <ParamField type={"object"}>
      An object populated with the error details of an unsuccessful form submission. `null` when `data` is not empty.
    </ParamField>
  </Expandable>
</ParamField>


# Transactions Dashboard
Source: https://docs.tight.com/embeddable-ui/react/bank-transactions/transactions-dashboard

The fully-featured experience for viewing and managing bank transactions

## Overview

The Transactions Dashboard is all you need to provide full transaction classification to your users, with a full user experience allowing your users to:

* Link bank accounts and credit cards
* See how transactions were segmented between revenue, expenses, refunds, bank transfers, and tax payments
* Drill into payouts, to understand which invoices, merchant fees, and other line items comprise a payout
* Review any transactions that Tight AI could not confidently categorize
* View/filter/search for transactions

<img alt="Transactions Dashboard Demo" />

<img alt="Mobile Transactions Dashboard Demo" />

## Embedding the Transactions Dashboard

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Transactions Dashboard:

```TSX TransactionsDashboard.tsx theme={null}
import { TransactionsDashboard, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function TransactionsDash({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <TransactionsDashboard />
      </Tight>
    )
}
```

## Props

<ParamField type={"Array<{ column: string; width?: number }>"}>
  An ordered array describing which table columns to display on the dashboard. Duplicate entries will
  be ignored.

  A column is an object with two fields, `column` and `width`.
  `column` is the name of the column. `width` is the desired pixel width of the column, and is optional.

  Available options: `date`, `description`, `amount`, `category`, `reviewStatus`, `dimensionValue`
</ParamField>

<ParamField type={"object"}>
  The set of filters to apply to the dashboard.

  Passing in a value for this prop turns this into a controlled component. As such, you must also pass the
  `onChangeFilters` prop to adjust the filters for user input.

  <Expandable title={"filters"}>
    <ParamField>
      Category filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all transactions in the given categories.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Dimension value filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all transactions belonging to the given dimension values.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      <Expandable title={"child attributes"}>
        <ParamField type={"string"}>
          Value - returns all transactions on the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all transactions not on the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all transactions after the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all transactions on or after the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all transactions before the given date.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all transactions on or before the given date.
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Review status filter

      <Expandable title={"child attributes"}>
        <ParamField type={"string[]"}>
          List of values to include.

          Available options: `RECONCILIATION_DISCREPANCY`, `USER_REVIEW_REQUIRED`, `ACCOUNTANT_REVIEW_REQUIRED`,
          `PARTNER_REVIEW_REQUIRED`, `AWAITING_MATCH`, `STAGED`, `RECONCILED`
        </ParamField>

        <ParamField type={"string[]"}>
          List of values to exclude.

          Available options: `RECONCILIATION_DISCREPANCY`,
          `USER_REVIEW_REQUIRED`,
          `ACCOUNTANT_REVIEW_REQUIRED`,
          `PARTNER_REVIEW_REQUIRED`,
          `AWAITING_MATCH`,
          `STAGED`,
          `RECONCILED`
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Type filter

      <Expandable title={"child attributes"}>
        <ParamField type={"string[]"}>
          List of values to include.

          Available options: `EXPENSE`,
          `REVENUE`,
          `BANK_TRANSFER`,
          `TAX_PAYMENT`,
          `INVOICE_PAYMENT`
        </ParamField>

        <ParamField type={"string[]"}>
          List of values to exclude.

          Available options: `EXPENSE`,
          `REVENUE`,
          `BANK_TRANSFER`,
          `TAX_PAYMENT`,
          `INVOICE_PAYMENT`
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the filters from the dashboard.
  This function will only be invoked if the `filters` prop is also provided. The callback takes `filters` as its single
  argument.
</ParamField>

<ParamField type={"number"}>
  The number of transactions to show on a single page of the Transactions Dashboard.
</ParamField>


# Banks & Integrations
Source: https://docs.tight.com/embeddable-ui/react/banks-and-integrations

All-in-one management page for connecting a user’s financial accounts

## Overview

The Banks & Integrations page gives users an intuitive way to manage all of their connected financial accounts and integrations, including:

* Linking bank accounts through Plaid
* Connecting other financial accounts via Tight's native integrations (e.g. Gusto, Shopify, Stripe)
* Creating and maintaining manual accounts
* Setting start dates and beginning balances
* Addressing connection or credential issues

<img alt="Banks & Integrations Demo" />

<img alt="Mobile Banks & Integrations Demo" />

## Embedding Banks & Integrations

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Banks & Integrations page:

```TSX HomeDashboard.tsx theme={null}
import { BanksAndIntegrations, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function HomeDashboard({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <BanksAndIntegrations />
      </Tight>
    )
}
```

## Props

<ResponseField name={"onPlaidLink"} type={"function"}>
  A callback function that is fired whenever a user attempts to open Plaid from the Banks & Integrations page (for
  example, when adding a new bank or resolving a connection issue).

  You should use this if and only if your application *already* includes Plaid Link, that way you can intercept any user
  action in Tight's Embedded UI that would invoke Plaid Link, so that *your* application can render Plaid Link.

  Alternatively, if omitted, Tight's Embedded UI handles all Plaid Link invocations on your behalf of your application.

  [//]: # "Using this prop will override the global `onPlaidLink` [Event listener](/embeddable-ui/react/reference/events/onPlaidLink)"

  [//]: # "within the embedded Banks & Integrations page."

  This function will be called with a single custom `EventData` argument with the following schema:

  <Expandable title="EventData schema">
    <ResponseField name="eventType" type="string">
      The name of the corresponding `EventType`. Always `"onPlaidLink"` for this event.
    </ResponseField>

    <ResponseField name="message" type="string">
      A human-readable message explaining the event. This is a convenience for developers consuming the event to understand the purpose of the event firing. This message should not be shown to users.
    </ResponseField>

    <ResponseField name="defaultPrevented" type="boolean">
      Whether the default action in the app was prevented. This will always be `true` for `onPlaidLink` events.
    </ResponseField>

    <ResponseField name="data" type="object">
      A custom data object containing details about the Plaid Link event.

      <Expandable>
        <ResponseField name="plaidEvent" type="string">
          Type of Plaid Link CTA that was pressed by your user. See below for information on how to handle each possible value.

          | Plaid Event | Description |
          | - | - |
          | `NEW` | Open Plaid Link so the the user can link a new financial institution |
          | `UPDATE` | Open Plaid Link to Update Mode using the provided `apiAccessToken`. |
          | `UNLINK` | Unlink the user's Plaid Integration. |
          | `UNLINK_RELINK` | Unlink the user's Plaid Integration, then ask them to link again. |
        </ResponseField>

        <ResponseField name="integrationId" type="string">
          The `id` of the Integration in Tight's database associated with the relevant institution. This value is
          always provided, except for the `plaidEvent` type `"NEW"`.
        </ResponseField>

        <ResponseField name="apiAccessToken" type="string">
          The access token from the Integration. This value is always provided, except for the `plaidEvent` type `"NEW"`.
        </ResponseField>

        <ResponseField name="apiErrorCode" type="string">
          The error code associated with the Plaid connection, if applicable.
        </ResponseField>
      </Expandable>
    </ResponseField>
  </Expandable>
</ResponseField>


# Bill Dashboard
Source: https://docs.tight.com/embeddable-ui/react/bills/bill-dashboard

The fully-featured experience for viewing and managing bills (A/P)

## Overview

The Bill Dashboard is all you need to provide full bill pay to your users, with a full user experience allowing your users to:

* Pay bills, including:
  * Choosing payment mechanism (e.g. ACH, Credit Card, Check)
  * Scheduling future payment dates
  * Set recurring payments
* Have bills automatically reconciled against bank deposits
* See payment status of bills
* Generate Aged AP reporting

## Embedding the Bill Dashboard

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Bill Dashboard:

```TSX BillDashboard.tsx theme={null}
import { BillDashboard, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function BillDash({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <BillDashboard />
      </Tight>
    )
}
```

## Props

<ParamField type={"object"}>
  The set of filters to apply to the dashboard.

  Passing in a value for this prop turns this into a controlled component. As such, you must also pass the
  `onChangeFilters` prop to adjust the filters for user input.

  <Expandable title={"filters"}>
    <ParamField>
      <Expandable title={"child attributes"}>
        <ParamField type={"string"}>
          Value - returns all records with specified field equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field not equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field greater than to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field greater than or equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field less than to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field less than or equal to this value.
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Type filter

      <Expandable title={"child attributes"}>
        <ParamField type={"string[]"}>
          List of values to include.

          Available options: `DRAFT`,
          `OPEN`,
          `CLOSED`,
          `CANCELED`,
          `REFUNDED`
        </ParamField>

        <ParamField type={"string[]"}>
          List of values to exclude.

          Available options: `DRAFT`,
          `OPEN`,
          `CLOSED`,
          `CANCELED`,
          `REFUNDED`
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the filters from the dashboard.
  This function will only be invoked if the `filters` prop is also provided. The callback takes `filters` as its single
  argument.
</ParamField>

<ParamField type={"number"}>
  The number of transactions to show on a single page of the Bill Dashboard.
</ParamField>


# Business Intelligence
Source: https://docs.tight.com/embeddable-ui/react/business-intelligence

Core business metrics at a glance

## Overview

Tight's Business Intelligence Tiles make it easy for you to provide your users with an easily digestible
overview of their business's key performance indicators. It also serves as a great way to onboard new users, as it
gives them a glimpse of the business intelligence they will receive by simply following a few quick onboarding steps.

## Tiles

### Profit and Loss

The Profit & Loss tile gives the user a quick snapshot of their business's profit after tax. Unlike many P\&Ls, the
final number in this tile subtracts out the business owner's tax obligation, yielding the single most important number
to every business owner.

<img alt="Profit and Loss Tile" />

### Cash Flow

The Cash Flow tile gives the user a quick snapshot of the cash flowing in and out of their business's bank accounts.
These inflows and outflows include all transaction types, including income (including loans/liabilities, funding/equity),
expenses (including assets purchased, owners draw), bank transfers, and tax payments.

<img alt="Cash Flow Tile" />

### Expenses

The Expense tile gives the user a quick snapshot of their business expense transactions, including the top spending
categories. This tile only includes the actual business expenses (i.e., it excludes capital assets, owner's draw, and
any other money spent that results in an addition to the Balance Sheet).

<img alt="Expense Tile" />

### Income

The Income tile gives the user a quick snapshot of their business income transactions. This tile only includes the
actual business income (i.e., it excludes bank transfers, loans received, and any other money received that results in an addition to the Balance Sheet).

### Invoices

The Invoice tile gives the user a quick snapshot of the invoices they have sent as well as the money they are still owed for open invoices.

### Taxes

The Tax tile gives the user a quick snapshot of their taxes owed. Tight estimates the federal, state, and self-employed
taxes that the business owner will owe, for all pass-through entity types.

## Embedding the Business Intelligence Tiles

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Business Intelligence tiles:

```TSX BusinessIntelligenceTiles.tsx theme={null}
import { CashFlowTile, ExpenseTile, ProfitAndLossTile, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

const containerStyle = {
  display: "flex",
  flexWrap: "wrap",
  justifyContent: "center",
  width: "100%",
};

function BusinessIntelligenceTiles({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <div style={containerStyle} >
          <ProfitAndLossTile />
          <ExpenseTile />
          <CashFlowTile />
        </div>
      </Tight>
    );
}
```

## Props

<ResponseField name={"showTooltip"} type={"boolean"}>
  Whether or not to show tooltips. Tooltips improve usability by providing quick explanations without cluttering
  the interface and help users understand tile data. To display them, pass this prop as `true`.
</ResponseField>

<ResponseField name={"onPress"} type={"function"}>
  A callback function invoked when the user presses on the tile. You can leverage this to route the user to the most
  relevant location within your app.

  Note: By default, if the user has not linked their bank through the Plaid integration clicking a tile will take them
  to the Plaid Link UX. Passing a custom `onPress` callback will override this behavior.
</ResponseField>

<ResponseField name={"dateRange"} type={"enum<string>"}>
  The date range that the tile will show data from.

  Available options: `ALL_TIME`, `THIS_MONTH`, `LAST_MONTH`, `LAST_3_MONTHS`, `LAST_12_MONTHS`, `THIS_QUARTER`, `LAST_QUARTER`, `THIS_YEAR`, `LAST_YEAR`
</ResponseField>


# Tight Dashboard
Source: https://docs.tight.com/embeddable-ui/react/financial-overview

All agentic accounting functionality in one place for the business owner

## Overview

The Tight Dashboard is all you need to provide full financials to your users, including:

* Onboarding-related action items like linking bank accounts and credit cards
* Monthly financial summaries
* As-needed action items whenever the business owner's attention is needed (e.g. the purpose of a bank transaction is unknown)
* Access to financial reporting (e.g. Profit & Loss, Balance Sheet, etc.)

<img alt="Tight Dashboard Demo" />

<img alt="Mobile Tight Dashboard Demo" />

## Embedding the Tight Dashboard

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Financial Overview:

```TSX HomeDashboard.tsx theme={null}
import { FinancialOverview, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function HomeDashboard({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <FinancialOverview />
      </Tight>
    )
}
```

## Props

<ResponseField name={"period"} type={"object"}>
  The time of year for which to show a financial summary, in terms of `month` and `year`. If not provided, the
  period defaults to the current month and year, though the user may navigate between months from the dashboard.

  Passing in a value for this prop turns this into a controlled component. As such, you must also pass the
  `onChangePeriod` prop to set the new value in the parent component.

  <Expandable title={"fields"}>
    <ResponseField name={"month"} type={"number"}>
      The month of the year for the displayed financial period. Must be a number between 0 and 11, where 0 is January
      and 11 is December.
    </ResponseField>

    <ResponseField name={"year"} type={"number"}>
      The year for the displayed financial period.
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name={"onChangePeriod"} type={"function"}>
  A function that is called whenever the user changes the viewed financial period from the dashboard.
  This function will only be invoked if the `period` prop is also provided. The callback takes `period` as its single
  argument.

  <Expandable title={"parameters"}>
    <ResponseField name={"period"} type={"object"}>
      The new financial period

      <Expandable title={"fields"}>
        <ResponseField name={"month"} type={"number"}>
          The month of the year for the displayed financial period. Must be a number between 0 and 11, where 0 is January
          and 11 is December.
        </ResponseField>

        <ResponseField name={"year"} type={"number"}>
          The year for the displayed financial period.
        </ResponseField>
      </Expandable>
    </ResponseField>
  </Expandable>
</ResponseField>


# Balance Sheet
Source: https://docs.tight.com/embeddable-ui/react/financial-statements/balance-sheet

View your business's assets, liabilities, and equity at a point in time

## Overview

A Balance Sheet is a financial statement that shows a snapshot of a business's assets, liabilities, and equity at a specific moment in time. The Balance Sheet provides insight into the business’s financial health by showing what the business owns and owes, which helps determine the business's ability to pay its obligations.

This financial statement can be customized to view and compare the account balances at different dates. It can even be drilled down into to see all of the transactions and journal entries contributing to the balance for each specific GL account.

## Embedding the interactive Balance Sheet

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Balance Sheet:

```TSX BalanceSheetReport.tsx theme={null}
import { BalanceSheet, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function BalanceSheetReport({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <BalanceSheet />
      </Tight>
    )
}
```

## Props

<ParamField>
  <Expandable title={"filters"}>
    <ParamField>
      Dimension value filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all entities with the following attachments.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField type={"object"}>
      The date range for which to show the report.

      Passing in a value for this prop turns this into a controlled component. As such, you must also pass the
      `onChangeDateRange` prop to set the new value in the parent component.

      <Expandable title={"fields"}>
        <ParamField type={"string"}>
          The beginning of the range, inclusive.
        </ParamField>

        <ParamField type={"string"}>
          The end of the range, inclusive.
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type={"string"}>
  The time period grouping of the report (e.g. for creating a month-over-month report).

  Available options: `NONE`, `MONTHLY`, `QUARTERLY`, `YEARLY`
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the grouping from the dashboard.
  This function will only be invoked if the `grouping` prop is also provided. The callback takes a `grouping` as its single
  argument.
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the filters from the dashboard.
  This function will only be invoked if the `filters` prop is also provided. The callback takes `filters` as its single
  argument.
</ParamField>


# Cash Flow Statement
Source: https://docs.tight.com/embeddable-ui/react/financial-statements/cash-flow-statement

Track the flow of cash in and out of your business

## Overview

A Cash Flow Statement (aka CFS, Statement of Cash Flows, or SCF) is a financial statement that provides a detailed overview of a business's cash movement during a specific period. The CFS provides insight into the business's operating, investing, and financing activities. This information helps the business understand their cash on hand, which informs their ability to operate in the short-term and long-term as well as their ability to fund business operations.

Tight provides an indirect CFS, which is divided into 3 sections:

* Operating Activities - This section includes the business's cash flow from core operations, including income generated and expenses paid
* Investing Activities - This section includes the business's cash flow from selling or purchasing assets
* Financing Activities - This section includes the business's cash flow from equity and debt

The bottom of the CFS summarizes the beginning and ending cash and the resulting cash on hand at the end of the reporting period.

## Embedding the interactive Cash Flow Statement

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Cash Flow Statement:

```TSX CashFlow.tsx theme={null}
import { CashFlowStatement, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function CashFlowReport({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <CashFlowStatement />
      </Tight>
    )
}
```

## Props

<ParamField>
  <Expandable title={"filters"}>
    <ParamField>
      Dimension value filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all entities with the following attachments.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField type={"object"}>
      The date range for which to show the report.

      Passing in a value for this prop turns this into a controlled component. As such, you must also pass the
      `onChangeDateRange` prop to set the new value in the parent component.

      <Expandable title={"fields"}>
        <ParamField type={"string"}>
          The beginning of the range, inclusive.
        </ParamField>

        <ParamField type={"string"}>
          The end of the range, inclusive.
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type={"string"}>
  The time period grouping of the report (e.g. for creating a month-over-month report).

  Available options: `NONE`, `MONTHLY`, `QUARTERLY`, `YEARLY`
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the grouping from the dashboard.
  This function will only be invoked if the `grouping` prop is also provided. The callback takes a `grouping` as its single
  argument.
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the filters from the dashboard.
  This function will only be invoked if the `filters` prop is also provided. The callback takes `filters` as its single
  argument.
</ParamField>


# Profit & Loss Report
Source: https://docs.tight.com/embeddable-ui/react/financial-statements/profit-loss-report

View your business's revenue, expenses, and profitability

## Overview

A Profit & Loss (P\&L) Report is a financial statement that summarizes the profitability (or lack thereof) for a business in a specific timeframe. The P\&L provides insight into the business’s financial performance by showing the overall profit or overall loss of the business for the specified timeframe, including where money was earned (income) and where money was spent (expenses).

The P\&L reflects the General Ledger (GL) accounts associated with each tracked transaction and journal entry. This financial statement can be customized to view and compare any of the tracked data. It can even be drilled down into to better understand all of the transactions and journal entries making up the total for each specific GL account within the reporting period.

## Embedding the interactive Profit and Loss Report

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Profit and Loss Report:

```TSX ProfitLoss.tsx theme={null}
import { ProfitAndLoss, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function ProfitLossReport({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <ProfitAndLoss />
      </Tight>
    )
}
```

## Props

<ParamField>
  <Expandable title={"filters"}>
    <ParamField>
      Dimension value filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all entities with the following attachments.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField type={"object"}>
      The date range for which to show the report.

      Passing in a value for this prop turns this into a controlled component. As such, you must also pass the
      `onChangeDateRange` prop to set the new value in the parent component.

      <Expandable title={"fields"}>
        <ParamField type={"string"}>
          The beginning of the range, inclusive.
        </ParamField>

        <ParamField type={"string"}>
          The end of the range, inclusive.
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type={"string"}>
  The time period grouping of the report (e.g. for creating a month-over-month report).

  Available options: `NONE`, `MONTHLY`, `QUARTERLY`, `YEARLY`
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the grouping from the dashboard.
  This function will only be invoked if the `grouping` prop is also provided. The callback takes a `grouping` as its single
  argument.
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the filters from the dashboard.
  This function will only be invoked if the `filters` prop is also provided. The callback takes `filters` as its single
  argument.
</ParamField>


# Report Dashboard
Source: https://docs.tight.com/embeddable-ui/react/financial-statements/report-dashboard

Access and manage all your business's financial reports

## Overview

Tight's Report Dashboard is a full-featured embedded experience (including all drill-down rows) for everything related to reports; all you need to do is add a "Reports" item to your product's navigation.

## Embedding the Report Dashboard

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Report Dashboard:

```TSX Reports.tsx theme={null}
import { ReportDashboard, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function Reports({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <ReportDashboard />
      </Tight>
    )
}
```

## Props

<ParamField type={"string[]"}>
  The set of reports to show on the dashboard.

  Available options: `AGED_ACCOUNTS_PAYABLE`, `AGED_ACCOUNTS_RECEIVABLE`, `BALANCE_SHEET`, `CASH_FLOW`, `EXPENSES_BY_CATEGORY`, `EXPENSES_BY_VENDOR`, `PROFIT_AND_LOSS`, `FORM_1040_SCHEDULE_C`, `FORM_1065`, `FORM_1120S`, `FORM_1120`, `T2125`, `TAX_SUMMARY`, `TRIAL_BALANCE`,
</ParamField>

<ParamField type={"boolean"}>
  If you prefer for the list of reports to not be broken into sections, you can set `showReportSections` to false.
</ParamField>


# Trial Balance Report
Source: https://docs.tight.com/embeddable-ui/react/financial-statements/trial-balance-report

Verify the accuracy of your business's accounting records

## Overview

A Trial Balance is a financial statement that shows the closing balance of each General Ledger (GL) account at a specific point in time. This report helps accountants perform a high-level audit of a business's books, ultimately ensuring everything is being tracked and accounted for accurately in the GL.

The Trial Balance displays the beginning balance, net debit or net credit, and ending balance of each GL account for the period. This report is primarily used to help the business owner ensure their debits and credits are accounted for properly in the GL and their books are balanced.

When viewing a Trial Balance, the bookkeeper can drill down into the report to see all of the transactions and journal entries contributing to the debit balance, credit balance, or ending balance for each specific GL account within the reporting period.

## Embedding the interactive Trial Balance

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Trial Balance:

```TSX TrialBalanceReport.tsx theme={null}
import { TrialBalance, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function TrialBalanceReport({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <TrialBalance />
      </Tight>
    )
}
```

## Props

<ParamField>
  <Expandable title={"filters"}>
    <ParamField>
      Dimension value filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all entities with the following attachments.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField type={"object"}>
      The date range for which to show the report.

      Passing in a value for this prop turns this into a controlled component. As such, you must also pass the
      `onChangeDateRange` prop to set the new value in the parent component.

      <Expandable title={"fields"}>
        <ParamField type={"string"}>
          The beginning of the range, inclusive.
        </ParamField>

        <ParamField type={"string"}>
          The end of the range, inclusive.
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type={"string"}>
  The time period grouping of the report (e.g. for creating a month-over-month report).

  Available options: `NONE`, `MONTHLY`, `QUARTERLY`, `YEARLY`
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the grouping from the dashboard.
  This function will only be invoked if the `grouping` prop is also provided. The callback takes a `grouping` as its single
  argument.
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the filters from the dashboard.
  This function will only be invoked if the `filters` prop is also provided. The callback takes `filters` as its single
  argument.
</ParamField>


# QuickBooks Online Import
Source: https://docs.tight.com/embeddable-ui/react/imports/quickbooks-online-import

Import accounting data from QuickBooks Online

## Overview

While [independent research shows that 62% of small businesses don't use any accounting software yet](https://www.tight.com/embedded-accounting-smb-vertical-software-report), leaving a major greenfield opportunity for your platform, Tight's customer-partners have also migrated thousands of businesses off of QuickBooks Online using Tight's QBO Import functionality.

The QBO Import functionality allows you to transfer a business’s QBO data into your embedded accounting platform, preserving the business’s historical financial information.

## Embedding the QuickBooks Online Import

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the QuickBooks Online Import:

```TSX QboImport.tsx theme={null}
import { AccountingImport, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function QboImport({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <AccountingImport type={"QBO"} />
      </Tight>
    )
}
```


# Wave Import
Source: https://docs.tight.com/embeddable-ui/react/imports/wave-import

Import accounting data from Wave

## Overview

While [independent research shows that 62% of small businesses don't use any accounting software yet](https://www.tight.com/embedded-accounting-smb-vertical-software-report), leaving a major greenfield opportunity for your platform, Tight's customer-partners have also migrated thousands of businesses off of QuickBooks Online using Tight's QBO Import functionality.

The Wave Import functionality allows you to transfer a business’s QBO data into your embedded accounting platform, preserving the business’s historical financial information.

## Embedding the Wave Import

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Wave Import:

```TSX WaveImport.tsx theme={null}
import { AccountingImport, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function WaveImport({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <AccountingImport type={"WAVE"} />
      </Tight>
    )
}
```


# Xero Import
Source: https://docs.tight.com/embeddable-ui/react/imports/xero-import

Import accounting data from Xero

## Overview

While [independent research shows that 62% of small businesses don't use any accounting software yet](https://www.tight.com/embedded-accounting-smb-vertical-software-report), leaving a major greenfield opportunity for your platform, Tight's customer-partners have also migrated thousands of businesses off of QuickBooks Online using Tight's QBO Import functionality.

The Xero Import functionality allows you to transfer a business’s QBO data into your embedded accounting platform, preserving the business’s historical financial information.

## Embedding the Xero Import

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Xero Import:

```TSX XeroImport.tsx theme={null}
import { AccountingImport, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function XeroImport({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <AccountingImport type={"XERO"} />
      </Tight>
    )
}
```


# Income Tax Dashboard
Source: https://docs.tight.com/embeddable-ui/react/income-tax-dashboard

Manage and track the business owner's income tax obligations

## Overview

The Income Tax Dashboard is all you need to provide full income tax functionality to the owner of a pass-through entity. Utilizing the Tight Income Tax API, which has been proven and reached maturity via very rigorous maintenance/update processes in place since the 2017 tax year, as well as painstaking quality assurance processes with a 1% threshold between 3 different sources.

The Tight Tax Calculations API currently supports the United States (50 states + DC) and Canada (all provinces, including GST/HST/PST/QST), but is architected for rapid expansion into other countries as needed.

The Income Tax Dashboard provides a full user experience, allowing your users to:

* Set up their tax profile
* View quarterly income tax estimates
* Generate Form 1040 Schedule C, Form 1065, Form 1120-S, Form 1120, and T2125 tax reports
* Download a full Tax Details report for hand-off to a tax preparer
* Transfer data into a white-labeled DIY tax filing platform, including April and Column Tax

## Embedding the Income Tax Dashboard

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Income Tax Dashboard:

```TSX IncomeTaxDash.tsx theme={null}
import { IncomeTaxDashboard, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function IncomeTaxDash({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <IncomeTaxDashboard />
      </Tight>
    )
}
```

## Props

<ParamField type={"object"}>
  The set of filters to apply to the dashboard.

  Passing in a value for this prop turns this into a controlled component. As such, you must also pass the
  `onChangeFilters` prop to adjust the filters for user input.

  <Expandable title={"filters"}>
    <ParamField>
      Used to route your user to a specific filtered view.

      The following periods are available:

      | Period | View |
      | - | - |
      | `YTD` | Annual |
      | `LAST_YEAR` | Annual |
      | `ALL_QUARTERS` | Quarterly |
      | `CURRENT_QUARTER` | Quarterly |
      | `ALL_QUARTERS_LAST_YEAR` | Quarterly |
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the filters from the dashboard.
  This function will only be invoked if the `filters` prop is also provided. The callback takes `filters` as its single
  argument.
</ParamField>


# Aged Accounts Receivable (A/R) Report
Source: https://docs.tight.com/embeddable-ui/react/invoicing/aged-accounts-receivable

Track and manage your outstanding customer invoices

## Overview

The Aged AR Report shows outstanding invoice totals, grouped on how many days they have been outstanding for, on a per-customer basis. This interactive report provides insight to the business owner-operator regarding how much money they are owed and what cash flow to realistically expect in the near future.

This interactive report can be drilled down into to see all of the individual invoices that are outstanding.

## Embedding the interactive Aged AR Report

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Aged AR Report:

```TSX AgedArReport.tsx theme={null}
import { AgedAccounts, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function AgedArReport({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <AgedAccounts />
      </Tight>
    )
}
```

## Props

<ParamField>
  <Expandable title={"filters"}>
    <ParamField>
      Dimension value filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all entities with the following attachments.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField type={"object"}>
      The date range for which to show the report.

      Passing in a value for this prop turns this into a controlled component. As such, you must also pass the
      `onChangeDateRange` prop to set the new value in the parent component.

      <Expandable title={"fields"}>
        <ParamField type={"string"}>
          The beginning of the range, inclusive.
        </ParamField>

        <ParamField type={"string"}>
          The end of the range, inclusive.
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type={"string"}>
  The number of due days for this report

  Available options: `ZERO_DAYS_AND_UP`, `THIRTY_ONE_DAYS_AND_UP`, `SIXTY_ONE_DAYS_AND_UP`, `NINETY_DAYS_AND_UP`
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the days overdue from the dashboard.
  This function will only be invoked if the `daysOverdue` prop is also provided. The callback takes a `daysOverdue` as its single
  argument.
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the filters from the report.
  This function will only be invoked if the `filters` prop is also provided. The callback takes `filters` as its single
  argument.
</ParamField>


# Customer-facing Invoice
Source: https://docs.tight.com/embeddable-ui/react/invoicing/customer-facing-invoice

The invoice view your customers see when they receive an invoice

## Overview

While the [Invoice Dashboard](/embeddable-ui/react/invoicing/invoice-dashboard) provides your users with what they need to create and manage invoices, the Customer-facing Invoice allows your users' customers to view and pay their invoices.

## Embedding the Customer-Facing Invoice

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Customer-Facing Invoice:

```TSX InvoicePaymentScreen.tsx theme={null}
import { CustomerInvoice, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function InvoicePaymentScreen({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <CustomerInvoice invoiceId={"inv_12345"} invoiceKey={"1234.abcdef"} />
      </Tight>
    )
}
```

## Props

<ParamField type={"string"}>
  The ID of the invoice to display to the customer.
</ParamField>

<ParamField type={"string"}>
  The secret key of the invoice so that only authorized customers may access the payment page.
</ParamField>

<ParamField type={"function"}>
  A function that is called when the user submits a payment. This is useful for triggering real-time notifications or
  logging.
</ParamField>


# Invoice Dashboard
Source: https://docs.tight.com/embeddable-ui/react/invoicing/invoice-dashboard

The fully-featured experience for viewing and managing invoices (A/R)

## Overview

The Invoice Dashboard is all you need to provide full invoicing to your users, with a full user experience allowing your users to:

* Create invoices with auto-complete line items, including:
  * Reimbursement for expenses (including mark-ups)
  * Ability to bill for time tracked
  * Manual line item creation
  * Sales tax line items
* Invoice template customization to match your user's business's branding, including:
  * Custom logo upload
  * Custom brand colors using color wheel or hex code
  * Ability to set business address and sender
* See status of invoices, including when the customer last viewed the invoice
* Generate Aged AR reporting

## Embedding the Invoice Dashboard

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Invoice Dashboard:

```TSX InvoiceDashboard.tsx theme={null}
import { InvoiceDashboard, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function InvoiceDash({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <InvoiceDashboard />
      </Tight>
    )
}
```

## Props

<ParamField type={"object"}>
  The set of filters to apply to the dashboard.

  Passing in a value for this prop turns this into a controlled component. As such, you must also pass the
  `onChangeFilters` prop to adjust the filters for user input.

  <Expandable title={"filters"}>
    <ParamField>
      <Expandable title={"child attributes"}>
        <ParamField type={"string"}>
          Value - returns all records with specified field equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field not equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field greater than to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field greater than or equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field less than to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field less than or equal to this value.
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Type filter

      <Expandable title={"child attributes"}>
        <ParamField type={"string[]"}>
          List of values to include.

          Available options: `DRAFT`,
          `OPEN`,
          `CLOSED`,
          `CANCELED`,
          `REFUNDED`
        </ParamField>

        <ParamField type={"string[]"}>
          List of values to exclude.

          Available options: `DRAFT`,
          `OPEN`,
          `CLOSED`,
          `CANCELED`,
          `REFUNDED`
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the filters from the dashboard.
  This function will only be invoked if the `filters` prop is also provided. The callback takes `filters` as its single
  argument.
</ParamField>

<ParamField type={"number"}>
  The number of transactions to show on a single page of the Invoice Dashboard.
</ParamField>


# Invoice Form
Source: https://docs.tight.com/embeddable-ui/react/invoicing/invoice-form

Create and edit invoices for your business

## Overview

The Invoice Form, which is also included within the [Invoice Dashboard](/embeddable-ui/react/invoicing/invoice-dashboard), is all you need to allow business owner-operators to create quotes and invoices, including:

* Auto-complete line items
* Reimbursement for expenses (including mark-ups)
* Ability to bill for time tracked
* Manual line item creation
* Sales tax line items

## Embedding the Invoice Form

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Invoice Form:

```TSX InvoiceForm.tsx theme={null}
import { InvoiceForm, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function InvForm({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <InvoiceForm id={"inv_12345"} />
      </Tight>
    )
}
```

## Props

<ParamField type={"string"}>
  The `invoice.id` that belongs to the form you would like to render.
</ParamField>


# Mileage Dashboard
Source: https://docs.tight.com/embeddable-ui/react/mileage-dashboard

Track and manage business mileage for tax deductions

## Overview

The Mileage Dashboard is all you need to provide full mileage tracking to your users, with a full user experience allowing your users to:

* Add drives, with auto-complete start and end addresses, route calculation/visualization, and reverse geocoding
* View drives/routes/addresses
* Classify drive purpose (business vs. personal)
* Define favorite locations
* Assign drives to dimensions

## Embedding the Mileage Dashboard

To initialize the Tight Embedded experience in your React project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/react/patterns/embedding).

Below is an example embedding of the Mileage Dashboard:

```TSX MileageDashboard.tsx theme={null}
import { MileageDashboard, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function MileageDash({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <MileageDashboard />
      </Tight>
    )
}
```

## Props

<ParamField type={"object"}>
  The set of filters to apply to the dashboard.

  Passing in a value for this prop turns this into a controlled component.
  As such, you must also pass the onChangeFilters prop to adjust the filters for user input.

  <Expandable title={"filters"}>
    <ParamField>
      Category filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all entities with the following attachments.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Dimension value filter

      <Expandable title={"child attributes"}>
        <ParamField type={"object"}>
          Id filter - returns all entities with the following attachments.

          <Expandable title={"child attributes"}>
            <ParamField type={"string[]"}>
              List of values to include.
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      <Expandable title={"child attributes"}>
        <ParamField type={"string"}>
          Value - returns all records with specified field equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field not equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field greater than to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field greater than or equal to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field less than to this value.
        </ParamField>

        <ParamField type={"string"}>
          Value - returns all records with specified field less than or equal to this value.
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      Review status filter

      <Expandable title={"child attributes"}>
        <ParamField type={"string[]"}>
          List of values to include.

          Available options: `RECONCILIATION_DISCREPANCY`, `USER_REVIEW_REQUIRED`, `ACCOUNTANT_REVIEW_REQUIRED`,
          `PARTNER_REVIEW_REQUIRED`, `AWAITING_MATCH`, `STAGED`, `RECONCILED`
        </ParamField>

        <ParamField type={"string[]"}>
          List of values to exclude.

          Available options: `RECONCILIATION_DISCREPANCY`,
          `USER_REVIEW_REQUIRED`,
          `ACCOUNTANT_REVIEW_REQUIRED`,
          `PARTNER_REVIEW_REQUIRED`,
          `AWAITING_MATCH`,
          `STAGED`,
          `RECONCILED`
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField>
      The type of drive to filter by

      <Expandable title={"child attributes"}>
        <ParamField type={"string[]"}>
          List of values to include.

          Available options: `BUSINESS`,
          `PERSONAL`,
        </ParamField>

        <ParamField type={"string[]"}>
          List of values to exclude.

          Available options: `BUSINESS`,
          `PERSONAL`,
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type={"function"}>
  A function that is called whenever the user changes the filters from the dashboard.
  This function will only be invoked if the `filters` prop is also provided. The callback takes `filters` as its single
  argument.
</ParamField>

<ParamField type={"number"}>
  The number of transactions to show on a single page of the dashboard.
</ParamField>


# Design
Source: https://docs.tight.com/embeddable-ui/react/patterns/design

Customize the Embedded UI to match your branding

## Get Started

Tight will work with you to understand your design needs and ensure the Embedded UI matches your brand. To begin, share one of the following:

* **Your application**: A login URL and credentials that Tight's design team can use to analyze your branding and styling
* **Design materials**: Brand guidelines, Figma files, or other design documentation
  <Tip>Every Tight React Page supports desktop web, mobile web, and all breakpoints in between</Tip>

## Initial Setup

Tight's design team will create an initial CSS file tailored to your brand. Once delivered, import it into your application:

```typescript theme={null}
import "@tight-embedded/react/index.css";
import "path/to/yourDesign.css";
```

<Note>
  Import order matters in CSS. Your custom CSS file must be imported **after** the Tight CSS file to ensure your overrides take effect.
</Note>

## Customizing Your Styles

You can submit a support request for design changes to Tight or make changes yourself using the methods below:

### Design Tokens

Tight uses design tokens to control styles throughout its system, making it easy for you to customize the look and feel
of components by changing just a few variables. As your entry point for customization, you can override the following
tokens:

```css theme={null}
:where(:root, :host) {
    /* Brand Colors - Primary */
    --Tight-colors-brand-primary

    /* Brand Colors - Secondary (subdued color, to complement your primary color) */
    --Tight-colors-brand-secondary

    /* Brand Colors - Action (buttons, links, interactive elements) */
    --Tight-colors-brand-action

    /* Brand Colors - Success */
    --Tight-colors-brand-success

    /* Brand Colors - Warning */
    --Tight-colors-brand-warning

    /* Brand Colors - Danger */
    --Tight-colors-brand-danger

    /* Surface Colors - Backgrounds and foregrounds */
    --Tight-colors-surface-background
    --Tight-colors-surface-foreground

    /* Font Colors */
    --Tight-colors-typography-base
    --Tight-colors-typography-base-weak
}
```

For more granular customization options, see the [full design token reference](/embeddable-ui/react/reference/design-tokens).

### CSS Classes

If you need more granularity than provided by the design tokens, you can directly override CSS classes on specific elements. All Tight component
classes are prefixed with `Tight-` and can be customized in your CSS file:

```css theme={null}
.Tight-tile {
    box-shadow: none;
}
```

**Inspecting elements**: Use your browser's developer tools to inspect elements and identify their class names. Only
override classes that start with `Tight-`. Overwriting any other classes is not supported, as they may change
in the future, and Tight does not guarantee backward compatibility.

<Note>
  If an element that you want to modify does not have a class, submit a support request for Tight to add it.
</Note>


# Embedding
Source: https://docs.tight.com/embeddable-ui/react/patterns/embedding

Get started with Tight Embeddable UI for React

## Get Started

<Tip>Every Tight React Page supports desktop web, mobile web, and all breakpoints in between</Tip>
Each Page is shipped in Tight's React Component Library, which can be installed as follows:

<CodeGroup>
  ```bash npm theme={null}
  npm install @tight-embedded/react@latest
  ```

  ```bash pnpm theme={null}
  pnpm add @tight-embedded/react@latest
  ```
</CodeGroup>

Once imported, you'll need to ensure that every Embeddable UI component is rendered in a React Tree
wrapped with a `<Tight>` component.

This is all you need to get going:

```TSX HomeDashboard.tsx theme={null}
import { FinancialOverviewDashboard, Tight } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function HomeDashboard({ accessToken }) {
    return (
      <Tight environment="SANDBOX" accessToken={accessToken} >
        <FinancialOverviewDashboard />
      </Tight>
    )
}
```

<Info>
  The ESLint rule `no-unresolved` might warn that `@tight-embedded/react/index.css` does not exist.

  Disable the lint rule on the import line, or import from `@tight-embedded/react/dist/index.css` directly. Please note that the
  direct path might change in future versions.
</Info>

Tight recommends adding a single `<Tight>` component towards the top of your application tree for maintainability.
The `<Tight>` component's `environment` property can be `"PRODUCTION"` or `"SANDBOX"`, depending on the environment you'd like to target. You can obtain an applicable `accessToken` via the Tight [Authentication Endpoint](/api-reference/authentication).

## Embed with AI (MCP)

The Tight Model Context Protocol (MCP) server provides tools that AI agents can use to embed end-to-end accounting utilizing Tight's documentation.

See the [Build with AI (MCP) guide](/guides/launch-paths/build-with-ai) for instructions and examples.


# CSS Patterns
Source: https://docs.tight.com/embeddable-ui/react/reference/css-patterns

Follow best practices for advanced customization of the Embedded UI

Tight uses specialized CSS patterns in certain components to ensure consistent behavior. When customizing these
components beyond what design tokens provide, you'll need to match these patterns to maintain the intended
functionality. This reference documents these patterns and explains how to work with them effectively.

## Hover Styles

Tight uses a CSS selector for the hover pseudo-class that ensures consistent behavior across touch-based devices.

**Recommended approach:** Modify the `hover` [design tokens](/embeddable-ui/react/reference/design-tokens#surface-colors) to customize hover styles. This is the simplest and most maintainable way to adjust hover colors and states.

**If design tokens aren't sufficient:** You may override the hover pseudo-class on a specific class directly for more granular control. Use the following selector pattern to ensure your rule takes precedence over the default:

```css theme={null}
@media (hover: hover) and (pointer: fine) {
  &:hover {
    /* Your hover styles here */
  }
}
```

This ensures hover styles only apply on devices that support hovering, preventing issues on touch-based devices where interactions could otherwise trigger unintended hover states.


# Design Tokens
Source: https://docs.tight.com/embeddable-ui/react/reference/design-tokens

Customize the Embedded UI to match your branding

Tight's design tokens are CSS custom properties that control the visual appearance of Tight's embedded UI components.
By overriding these tokens in your application's CSS, you can customize typography, colors, spacing, and other design
elements to match your brand identity.

Please refer to the [Design reference](/embeddable-ui/react/patterns/design) for information on how to get started with
Design Tokens.

## How to Use Design Tokens

To customize design tokens, define them in your CSS file before initializing Tight components:

```css theme={null}
:where(:root, :host) {
  --Tight-colors-brand-primary: #5FDD9C;
  --Tight-fonts-body: 'Inter', sans-serif;
  --Tight-radii-md: 8px;
}
```

All design tokens are optional. Any token not explicitly set will use Tight's default values.

## Font Tokens

Tight provides many tokens that you can use to customize fonts throughout Tight's components. Tight categorizes text into four main categories:

* **Body** - For blocks of text, user input, main page content
* **Label** - Denoting purpose, information, or an atomic reason
* **Heading** - Explains purpose of content before reading further
* **Metric** - For numbers in graphs, financial statements, etc.

### Font Family

Controls the typeface used for text.

**Global**

Controls the typeface for all text globally.

```css theme={null}
--Tight-fonts-base
```

**Text Type Specific**

Specify the typeface for different text categories. All text defaults to the font family of the base token unless overwritten.

```css theme={null}
--Tight-fonts-body
--Tight-fonts-label
--Tight-fonts-heading
--Tight-fonts-metric
```

If you'd like to use the default fonts from Tight you'll need to include the following additional CSS imports:

```TSX theme={null}
import "@tight-embedded/react/duplet.css";
import "@tight-embedded/react/inter.css";
```

### Font Size

Controls text size across the application. You can override global size scales or target specific text categories.

**Global Scale**

Use these to establish consistent sizing across all components:

```css theme={null}
--Tight-fontSizes-sm
--Tight-fontSizes-md
--Tight-fontSizes-lg
--Tight-fontSizes-xl
```

**Text Type Specific**

Fine-tune sizes for individual text categories:

```css theme={null}
--Tight-fontSizes-title
--Tight-fontSizes-body
--Tight-fontSizes-label
--Tight-fontSizes-label-strong
--Tight-fontSizes-label-sub
--Tight-fontSizes-label-strongSub
--Tight-fontSizes-heading
--Tight-fontSizes-metric-sm
--Tight-fontSizes-metric-md
--Tight-fontSizes-metric-lg
--Tight-fontSizes-metric-xl
```

### Font Weight

Controls text weight (boldness) throughout the application.

**Global Scale**

```css theme={null}
--Tight-fontWeights-sm
--Tight-fontWeights-md
--Tight-fontWeights-lg
```

**Text Type Specific**

```css theme={null}
--Tight-fontWeights-body
--Tight-fontWeights-label
--Tight-fontWeights-label-strong
--Tight-fontWeights-label-sub
--Tight-fontWeights-label-strongSub
--Tight-fontWeights-heading
--Tight-fontWeights-title
--Tight-fontWeights-metric-sm
--Tight-fontWeights-metric-md
--Tight-fontWeights-metric-lg
--Tight-fontWeights-metric-xl
```

## Layout Tokens

### Border Radius

Controls the corner rounding of UI elements like cards, buttons, and inputs.

```css theme={null}
--Tight-radii-sm
--Tight-radii-md
--Tight-radii-lg
```

### Border Width

Controls the thickness of borders on UI elements.

```css theme={null}
--Tight-borderWidths-sm
--Tight-borderWidths-md
--Tight-borderWidths-lg
--Tight-borderWidths-xl
```

## Color Tokens

Color tokens control the color palette throughout Tight's UI. They're organized into semantic categories to ensure consistent visual communication.

### Brand Colors

Define your core brand identity with primary, secondary, action, etc. colors. Each color includes intensity variants (`weak`, `strong`, `stronger`, `strongest`) for creating visual hierarchy.

```css theme={null}
--Tight-colors-brand-primary-weak
--Tight-colors-brand-primary
--Tight-colors-brand-primary-strong
--Tight-colors-brand-secondary-weak
--Tight-colors-brand-secondary
--Tight-colors-brand-secondary-strong
--Tight-colors-brand-action-weak
--Tight-colors-brand-action
--Tight-colors-brand-action-strong
--Tight-colors-brand-action-stronger
--Tight-colors-brand-action-strongest
--Tight-colors-brand-success-weak
--Tight-colors-brand-success
--Tight-colors-brand-success-strong
--Tight-colors-brand-warning-weak
--Tight-colors-brand-warning
--Tight-colors-brand-warning-strong
--Tight-colors-brand-danger-weak
--Tight-colors-brand-danger
--Tight-colors-brand-danger-strong
```

### Surface Colors

Surface colors define backgrounds and containers for UI elements.

**Base Surfaces**

```css theme={null}
--Tight-colors-surface-background
--Tight-colors-surface-background-hover
--Tight-colors-surface-foreground
--Tight-colors-surface-foreground-hover
--Tight-colors-surface-foreground-disabled
--Tight-colors-surface-elevated
--Tight-colors-surface-elevated-hover
```

**Intent Surfaces**

Applied to interactive elements like buttons to communicate their purpose and state.

```css theme={null}
--Tight-colors-surface-intent-primary
--Tight-colors-surface-intent-primary-hover
--Tight-colors-surface-intent-primary-active
--Tight-colors-surface-intent-primary-disabled
--Tight-colors-surface-intent-secondary
--Tight-colors-surface-intent-secondary-hover
--Tight-colors-surface-intent-secondary-active
--Tight-colors-surface-intent-secondary-disabled
--Tight-colors-surface-intent-action
--Tight-colors-surface-intent-action-hover
--Tight-colors-surface-intent-action-active
--Tight-colors-surface-intent-action-disabled
--Tight-colors-surface-intent-action-discrete
--Tight-colors-surface-intent-action-discrete-hover
--Tight-colors-surface-intent-action-discrete-active
--Tight-colors-surface-intent-success
--Tight-colors-surface-intent-success-hover
--Tight-colors-surface-intent-success-active
--Tight-colors-surface-intent-success-disabled
--Tight-colors-surface-intent-warning
--Tight-colors-surface-intent-warning-hover
--Tight-colors-surface-intent-warning-active
--Tight-colors-surface-intent-warning-disabled
--Tight-colors-surface-intent-danger
--Tight-colors-surface-intent-danger-hover
--Tight-colors-surface-intent-danger-active
--Tight-colors-surface-intent-danger-disabled
```

### Typography Colors

Controls text colors across all components.

**Base Colors**

```css theme={null}
--Tight-colors-typography-base
--Tight-colors-typography-base-weak
--Tight-colors-typography-contrast
--Tight-colors-typography-contrast-weak
```

**Text Type Specific**

```css theme={null}
--Tight-colors-typography-body
--Tight-colors-typography-label
--Tight-colors-typography-label-sub
--Tight-colors-typography-label-strong
--Tight-colors-typography-label-strongSub
--Tight-colors-typography-heading
--Tight-colors-typography-metric-sm
--Tight-colors-typography-metric-md
--Tight-colors-typography-metric-lg
--Tight-colors-typography-metric-xl
```

**Accent Colors**

Used for highlighting special states like successes, warnings, and errors.

```css theme={null}
--Tight-colors-typography-accent-success
--Tight-colors-typography-accent-warning
--Tight-colors-typography-accent-danger
```

**Intent Colors**

Applied to interactive elements like buttons to communicate their purpose and state.

```css theme={null}
--Tight-colors-typography-intent-primary
--Tight-colors-typography-intent-primary-hover
--Tight-colors-typography-intent-primary-active
--Tight-colors-typography-intent-secondary
--Tight-colors-typography-intent-secondary-hover
--Tight-colors-typography-intent-secondary-active
--Tight-colors-typography-intent-action
--Tight-colors-typography-intent-action-hover
--Tight-colors-typography-intent-action-active
--Tight-colors-typography-intent-success
--Tight-colors-typography-intent-success-hover
--Tight-colors-typography-intent-success-active
--Tight-colors-typography-intent-warning
--Tight-colors-typography-intent-warning-hover
--Tight-colors-typography-intent-warning-active
--Tight-colors-typography-intent-danger
--Tight-colors-typography-intent-danger-hover
--Tight-colors-typography-intent-danger-active
```

### Icon Colors

Controls icon colors throughout the application. These tokens inherit their values from the typography color tokens unless overwritten.

**Base Colors**

```css theme={null}
--Tight-colors-icon-base
--Tight-colors-icon-base-weak
--Tight-colors-icon-contrast
--Tight-colors-icon-contrast-weak
```

**Accent Colors**

```css theme={null}
--Tight-colors-icon-accent-success
--Tight-colors-icon-accent-warning
--Tight-colors-icon-accent-danger
```

**Intent Colors**

Applied to interactive elements like buttons to communicate their purpose and state.

```css theme={null}
--Tight-colors-icon-intent-primary
--Tight-colors-icon-intent-primary-hover
--Tight-colors-icon-intent-primary-active
--Tight-colors-icon-intent-secondary
--Tight-colors-icon-intent-secondary-hover
--Tight-colors-icon-intent-secondary-active
--Tight-colors-icon-intent-action
--Tight-colors-icon-intent-action-hover
--Tight-colors-icon-intent-action-active
--Tight-colors-icon-intent-success
--Tight-colors-icon-intent-success-hover
--Tight-colors-icon-intent-success-active
--Tight-colors-icon-intent-warning
--Tight-colors-icon-intent-warning-hover
--Tight-colors-icon-intent-warning-active
--Tight-colors-icon-intent-danger
--Tight-colors-icon-intent-danger-hover
--Tight-colors-icon-intent-danger-active
```

### Border Colors

Controls border colors across the application.

**Base Layout Borders**

```css theme={null}
--Tight-colors-border-layout-weak
--Tight-colors-border-layout
--Tight-colors-border-layout-strong
```

**Intent Borders**

Applied to interactive elements like buttons to communicate their purpose and state.

```css theme={null}
--Tight-colors-border-intent-primary-hover
--Tight-colors-border-intent-primary
--Tight-colors-border-intent-primary-active
--Tight-colors-border-intent-primary-disabled
--Tight-colors-border-intent-secondary-hover
--Tight-colors-border-intent-secondary
--Tight-colors-border-intent-secondary-active
--Tight-colors-border-intent-secondary-disabled
--Tight-colors-border-intent-danger-hover
--Tight-colors-border-intent-danger
--Tight-colors-border-intent-danger-active
--Tight-colors-border-intent-danger-disabled
--Tight-colors-border-intent-warning-hover
--Tight-colors-border-intent-warning
--Tight-colors-border-intent-warning-active
--Tight-colors-border-intent-warning-disabled
--Tight-colors-border-intent-success-hover
--Tight-colors-border-intent-success
--Tight-colors-border-intent-success-active
--Tight-colors-border-intent-success-disabled
--Tight-colors-border-intent-action-hover
--Tight-colors-border-intent-action
--Tight-colors-border-intent-action-active
--Tight-colors-border-intent-action-disabled
```

### Money Colors

Specialized colors for displaying financial data in reports and graphs.

```css theme={null}
--Tight-colors-money
--Tight-colors-money-positive
--Tight-colors-money-positive-weak
--Tight-colors-money-negative
--Tight-colors-money-negative-weak
```

## Animation Tokens

Controls animation timing for transitions and appearance effects.

```css theme={null}
--Tight-animations-appear-instant
--Tight-animations-appear-delay
```

## Shadow Tokens

Controls drop shadows for elevated UI elements like modals, popovers, and cards.

```css theme={null}
--Tight-shadows-box-shadow
```


# Event Listeners
Source: https://docs.tight.com/embeddable-ui/react/reference/event-listeners

Observe and intercept actions taken inside the Tight Embeddable UI

## Overview

Event listeners are used to observe and intercept actions taken inside the Embeddable UI. You might, for example,
react to a user linking a bank account, or take over the library's built-in behavior entirely.

Listeners are shared across all instances of the Embeddable UI. Registrations across different components share the
same state, and the last registration for a given key wins, so prefer a single registration site per event key to
avoid conflicts.

The available events are listed below under [Reference](#reference).

## Use Cases

Event listeners open up a wide range of possibilities for tailoring the Embeddable UI to your platform. The examples
below illustrate some common patterns.

### Invoice Routing

If your platform has its own invoicing, event listeners let you route users back to your invoices from within the
Embeddable UI. For example, a vertical SaaS platform issues invoices through its own product, and the Tight
[Transactions Dashboard](/embeddable-ui/react/bank-transactions/transactions-dashboard) shows a payout that includes three of those invoices. When the user clicks on one of those
invoices, you can intercept the click and route the user to the corresponding invoice in your platform instead.

### Paywall Enforcement

Event listeners also let you gate specific functionality behind your own pricing tiers. For example, a horizontal SaaS
platform wants to offer Tax Estimates only on a paid plan. When a user clicks into tax-related functionality,
the platform intercepts the routing and shows its own paywall screen instead of the built-in tax experience.

## Setting Listeners

Listeners are accessed via the `useEmbeddedEventListeners` hook. Keep in mind that this must be used within a `<Tight>`
component. Listener declaration is done either by passing initial listeners to the hook, or by using the `setListeners`
function returned by it. This function accepts a subset of all possible listeners, and will merge any input into your
already defined listeners. This means that both this:

```TypeScript theme={null}
import { useEmbeddedEventListeners } from "@tight-embedded/react";
// ...
const [listeners, setListeners] = useEmbeddedEventListeners({
  plaidLink: {
    listener: (event) => {
      if (event.result === "SUCCESS") {
        console.log("Bank linked:", event.type);
      }
    },
  },
});
```

and this:

```TypeScript theme={null}
import { useEmbeddedEventListeners } from "@tight-embedded/react";
// ...
const [listeners, setListeners] = useEmbeddedEventListeners();
setListeners({
  plaidLink: {
    listener: (event) => {
      if (event.result === "SUCCESS") {
        console.log("Bank linked:", event.type);
      }
    },
  },
});
```

are valid methods of defining the same set of listeners.

<Note>
  The initial listeners passed to `useEmbeddedEventListeners` are only applied once, on mount. Re-renders do not
  re-apply them. To update a listener after mount, use `setListeners`.
</Note>

### Updating Listeners

Since `setListeners` accepts a subset of listeners, you're able to update your listeners at any time after mount. The
code below adds a `gusto` listener without affecting any previously registered keys.

```TypeScript theme={null}
setListeners({
  gusto: { listener: handleGusto, preventDefault: true },
});
```

Note that listener merging is a *shallow merge* - input is only merged at the top level.

### Removing Listeners

If you want to remove a listener, pass `null` for its key. Unrelated keys are preserved.

```TypeScript theme={null}
setListeners({ gusto: null });
```

### Preventing Default Behavior

Each listener is registered as an `EventRegistration`, which pairs your callback with an optional `preventDefault`
flag. When `preventDefault` is `true`, the library's built-in behavior for that event is suppressed (for example, the
Plaid modal will not open; the transaction drawer will not open). When `false` or omitted, both your listener and the
default behavior run.

For example, to open a bank's website in a custom in-app browser instead of a new tab, suppress the default behavior
and handle the navigation yourself:

```TypeScript theme={null}
setListeners({
  plaidLink: {
    preventDefault: true,
    listener: (event) => {
      if (event.type === "PLAID_LINK_ROUTE_TO_BANK" && event.result === "SUCCESS") {
        openInAppBrowser(event.data.bankUrl);
      }
    },
  },
});
```

### Handling Events

Every event is a discriminated union with a `result` field:

```TypeScript theme={null}
type TightEvent<T, D, E> =
  | { type: T; result: "SUCCESS"; data: D;    error: null }
  | { type: T; result: "FAILURE"; data: null; error: E    }
```

Always branch on `event.result` before reading `data` or `error`.

```TypeScript theme={null}
listener: (event) => {
  if (event.result === "SUCCESS") {
    // event.data is typed
  } else {
    // event.error is typed
  }
}
```

## Reference

`useEmbeddedEventListeners` returns a `[listeners, setListeners]` tuple:

<ResponseField name="listeners" type="object">
  A snapshot of all currently registered listeners.
</ResponseField>

<ResponseField name="setListeners" type="function">
  A function to merge new registrations into the existing state. Each key accepts an `EventRegistration`, or `null`
  to remove that listener.

  <Expandable title="EventRegistration">
    <ParamField type="function">
      The callback fired when the event occurs.
    </ParamField>

    <ParamField type="boolean">
      Whether or not the library's built-in default behavior for this event should be suppressed. When `false`
      or omitted, both your listener and the default behavior run.
    </ParamField>
  </Expandable>
</ResponseField>

### Events

Each row below is a registration key you can pass to `useEmbeddedEventListeners`. The **Event types** column lists the `event.type` values a single registration may receive, and the data and error shapes are the payloads on `SUCCESS` and `FAILURE` results respectively.

| Registration key | Description | Event types, data, and error shapes |
| - | - | - |
| `plaidLink` | Fires at the start of each bank-linking action; a single registration handles all lifecycle types. `preventDefault: true` prevents the Plaid modal from opening, letting you manage the flow yourself. | Types: `PLAID_LINK_NEW`, `PLAID_LINK_RESET`, `PLAID_LINK_RELINK`, `PLAID_LINK_UNLINK`, `PLAID_LINK_ROUTE_TO_BANK`. Data on `SUCCESS`: `{ plaidAccessToken: string } \| null` (reset/relink/unlink), `{ bankUrl: string }` (route to bank), or `null` (new). Error on `FAILURE`: `{ errorCode: string }`. |
| `plaidLinkEvent` | Fires for every event emitted by the Plaid SDK during the link flow. Useful for analytics. | Type: `PLAID_LINK_EVENT`. Data on `SUCCESS`: `{ eventName: string; metadata: unknown }`. |
| `plaidLinkError` | Fires when the Plaid flow encounters an error or the user exits with an error. | Type: `PLAID_LINK_FAILURE`. Error on `FAILURE`: `{ displayMessage: string; errorCode: string; errorMessage: string }`. |
| `gusto` | Fires when the user taps "Connect Gusto" in the Banks & Integrations section. `preventDefault: true` suppresses the built-in Gusto OAuth flow so you can initiate OAuth from your own backend. | Type: `GUSTO_NEW`. Data on `SUCCESS`: `null`. |
| `conversations` | Fires when the user opens or starts a conversation. `preventDefault: true` suppresses the library's conversation drawer. | Type: `OPEN_CONVERSATION`. Data on `SUCCESS`: `ConversationGetDto` (existing conversation), `{ defaultValues: MessageFormValues }` (new conversation with pre-filled text), or `null` (blank new conversation). |
| `transactionForm` | Fires when a transaction form opens or closes; delineates between transactions from processor (ie. Stripe, Square, etc.) and non-processor sources. `preventDefault: true` on open prevents the library's transaction drawer from opening, letting you render your own UI. | Types: `OPEN_BANK_TRANSACTION_FORM`, `CLOSE_BANK_TRANSACTION_FORM`, `OPEN_PROCESSOR_TRANSACTION_FORM`, `CLOSE_PROCESSOR_TRANSACTION_FORM`. Data on `SUCCESS`: `BankTransaction` (editing), `null` (creating), or `BankTransaction \| null` (close). Error on `FAILURE`: `Record<string, unknown>`. |
| `bankTransactionForm` | Fires when a transaction form for a bank transaction (ie. Plaid, Unit, etc) opens or closes. Use this instead of `transactionForm` when you want to handle bank transactions separately from processor transactions. `preventDefault: true` on open prevents the library's transaction drawer from opening, letting you render your own UI. | Types: `OPEN_BANK_TRANSACTION_FORM`, `CLOSE_BANK_TRANSACTION_FORM`. Data on `SUCCESS`: `BankTransaction` (editing), `null` (creating), or `BankTransaction \| null` (close). Error on `FAILURE`: `Record<string, unknown>`. |
| `processorTransactionForm` | Fires when a transaction form for a processor transaction (ie. Stripe, Square, etc.) opens or closes. Use this instead of `transactionForm` when you want to handle processor transactions separately from bank transactions. `preventDefault: true` on open prevents the library's transaction drawer from opening, letting you render your own UI. | Types: `OPEN_PROCESSOR_TRANSACTION_FORM`, `CLOSE_PROCESSOR_TRANSACTION_FORM`. Data on `SUCCESS`: `BankTransaction` (editing), `null` (creating), or `BankTransaction \| null` (close). Error on `FAILURE`: `Record<string, unknown>`. |
| `bITile` | Financial dashboard tiles. Fires when a dashboard tile mounts. Useful for tracking which tiles are visible. `preventDefault` has no effect on tile events. | Types: `CASH_FLOW_TILE`, `EXPENSE_TILE`, `PROFIT_AND_LOSS_TILE`. Result: `SUCCESS` when the corresponding tile mounts. |
| `bill` | Bill drawer. Fires when the user opens a bill. | Type: `OPEN_BILL`. Data on `SUCCESS`: `BillGetDto`. Error on `FAILURE`: `Record<string, unknown>`. |
| `customer` | Customer selector/form. Fires when the user opens the customer selector or form. | Type: `OPEN_CUSTOMER`. Data on `SUCCESS`: `CustomerGetDto` (existing customer) or `null` (new customer). |
| `invoice` | Invoice form. Fires when the user opens an existing invoice. `preventDefault: true` prevents the library's invoice form from opening, letting you render your own UI. | Type: `OPEN_INVOICE_FORM`. Data on `SUCCESS`: `InvoiceGetDto`. Error on `FAILURE`: `Record<string, unknown>`. |
| `payroll` | Payroll record. Fires when the user opens a payroll record. | Type: `OPEN_PAYROLL`. Data on `SUCCESS`: `{ data: PayrollGetDto }`. |
| `taxDashboardZeroStateCTA` | Fires when the user clicks the zero-state call to action on the Tax Dashboard. | Type: `TAX_DASH_CTA`. Data on `SUCCESS`: `null`. |
| `taxProfileCTA` | Fires when the user clicks the tax profile call to action on the Tax Dashboard or Financial Overview. | Type: `TAX_PROFILE_CTA`. Data on `SUCCESS`: `null`. |
| `taxFilingCTA` | Fires when the user clicks a tax filing call to action on the Tax Dashboard. | Type: `TAX_FILING_CTA`. Data on `SUCCESS`: `{ action: "CONTINUE" \| "VIEW" \| null }`. |
| `learnMore` | Fires when the user clicks a "Learn more" link within the import flows. | Types: `IMPORT_CSV_LEARN_MORE`, `IMPORT_RULES_LEARN_MORE`, `SCRIPT_BLOCKER_LEARN_MORE`, `IMPORT_XERO_LEARN_MORE`. Data on `SUCCESS`: `null`. |
| `paymentProcessorTutorial` | Fires when the user opens the payment processor tutorial from the Invoice Dashboard or Financial Overview. | Type: `PAYMENT_PROCESSOR_TUTORIAL`. Data on `SUCCESS`: `null`. |
| `paymentProcessing` | Fires for payment processing actions, such as refunding an invoice from the Invoice Dashboard or setting up payment processing. | Types: `REFUND_INVOICE`, `SETUP_PAYMENT_PROCESSING`. Data on `SUCCESS`: `{ invoiceId: string }` (refund) or `null` (setup). |
| `renderClientInvoice` | Fires when a client pays an invoice from the client-facing invoice view. | Type: `PAY_INVOICE`. Data on `SUCCESS`: `{ invoiceId: string; invoiceName: string; invoiceBalance: number }`. |
| `incomeDashCTA` | Fires when the user clicks the send invoice call to action on the Income Dashboard. | Type: `SEND_INVOICE`. Data on `SUCCESS`: `null`. |
| `accountantUserAction` | Fires when an accountant takes an action on a user. | Type: `ACCOUNTANT_USER_ACTION`. Data on `SUCCESS`: `{ value: string; userId: string }`. |
| `accountant` | Fires when members or teammates are added, updated, removed, or restored. | Types: `ADD_MEMBERS`, `UPDATE_MEMBERS`, `REMOVE_MEMBERS`, `RESTORE_MEMBERS`, `ADD_TEAMMATE`, `UPDATE_TEAMMATE`, `REMOVE_TEAMMATE`, `RESTORE_TEAMMATE`. Data on `SUCCESS`: `{ users: Array<{ id: string; userId: string; email?: string }> }` (member types), `{ teammate: object }` (add/update teammate), or `{ id: string; userId: string }` (remove/restore teammate). |
| `import` | Fires when an import flow completes. | Types: `IMPORT_EXPENSE_RULES_COMPLETED`, `IMPORT_QBO_COMPLETED`, `IMPORT_XERO_COMPLETED`, `IMPORT_BENCH_COMPLETED`, `IMPORT_WAVE_COMPLETED`. Data on `SUCCESS`: `null`. |

### TypeScript

All types are exported from `@tight-embedded/react`:

```TypeScript theme={null}
import type {
  TightEvent,
  TightEventListener,
  TightEvents,
  EventRegistration,
  PlaidLinkEvent,
  UseEmbeddedEventListenersResult,
} from "@tight-embedded/react";
```


# Options
Source: https://docs.tight.com/embeddable-ui/react/reference/options

Customize your user's experience

## Overview

Options are used to customize the user's experience beyond just branding. You might, for example, customize the page
size limit to match the rest of your application.

Options are shared across all instances of the Embeddable UI.
Some of these options will be applied globally, and some will only affect a subset of the app.

The global options are listed below. You can see which options are available for each Page or Component
under the relevant reference.

## Setting Options

Options are accessed via the `useOptions` hook. Keep in mind that this must be used within a `<Tight>` component.
Option declaration is done using the `setOptions` function returned by `useOptions`.
This function accepts a [`Partial`](https://www.typescriptlang.org/docs/handbook/utility-types.html#partialtype) of all
possible options, and will merge any input into your already defined options. This means that both this:

```TypeScript theme={null}
import { useOptions } from "@tight-embedded/react";
// ...
const { options, setOptions } = useOptions({
  transactionsDashboard: { limit: 50 },
  dataVisualizationColors: ["#F00", "#0F0", "#00F"],
});
```

and this:

```TypeScript theme={null}
import { useOptions } from "@tight-embedded/react";
// ...
const { options, setOptions } = useOptions();
setOptions({ transactionsDashboard: { limit: 50 }});
setOptions({ dataVisualizationColors: ["#F00", "#0F0", "#00F"] });
```

are valid method of defining the same set of options.

### Updating Options

Since `setOptions` accepts a `Partial`, you're able to update a subset of your options. The code below updates the `limit`
on the Transactions Dashboard from 50 to 100 after a second, as an example.

```TypeScript theme={null}
setOptions({ transactionsDashboard: { limit: 50 } })

setTimeout(() => {
  setOptions({ transactionsDashboard: { limit: 100 } })
}, 1000)
```

Note that option merging is a *shallow merge* - input is only merged at the top level.

```TypeScript theme={null}
setOptions({
  transactionsDashboard: { limit: 50 },
  dataVisualizationColors: ["#F00", "#0F0", "#00F"],
})
// This will remove your previously set limit!
setOptions({ transactionsDashboard: {} })
```

### Replacing Options

If you want to update your options to be *exactly* what you've passed as input to `setOptions`, you can pass the
`replace` parameter as `true`.

```TypeScript theme={null}
setOptions({
  transactionsDashboard: { limit: 50 },
  dataVisualizationColors: ["#F00", "#0F0", "#00F"],
})

setOptions({ transactionsDashboard: { limit: 100 } }, true)
```

The above example will result in an options state like this:

```TypeScript theme={null}
{ transactionsDashboard: { limit: 100 } }
```

<Note>
  Note that option merging is a *shallow merge* - input is only merged at the top level.
</Note>

## Reference

<ResponseField name="options" type="object">
  The options to update the Embeddable UI state

  <Expandable title="options">
    <ResponseField name={"transactionsDashboard"} type={"object"}>
      The options for the [Transactions Dashboard](/embeddable-ui/react/bank-transactions/transactions-dashboard).

      <Expandable title={"transactionsDashboard"}>
        <ParamField type={"Array<{ column: string; width?: number }>"}>
          An ordered array describing which table columns to display on the dashboard. Duplicate entries will
          be ignored.

          A column is an object with two fields, `column` and `width`.
          `column` is the name of the column. `width` is the desired pixel width of the column, and is optional.

          Available options: `date`, `description`, `amount`, `category`, `reviewStatus`, `dimensionValue`
        </ParamField>

        <ParamField type={"number"}>
          The number of transactions to show on a single page of the Transactions Dashboard.
        </ParamField>
      </Expandable>
    </ResponseField>

    <ResponseField name={"dataVisualizationColors"} type={"string[]"}>
      An array of colors (represented as a `string` in hexadecimal format) that define the color palette for
      various graphs and diagrams across the Embeddabl e UI. This is only used for metrics that don't
      already have color associations, such as the colors for each category on the Expense Tile.
    </ResponseField>

    <ResponseField name={"banksAndIntegrations"} type={"object"}>
      The options for the Banks & Integrations related functionality.

      <Expandable title={"banksAndIntegrations"}>
        <ParamField type={"string[]"}>
          An array of integration identifiers that determines which integrations are displayed as linkable integrations. If not provided, all supported integrations are shown by default. If a user
          already has an integration linked that is not included in this list, it will still be shown to the user.

          Supported integration identifiers: `UNIT`, `STRIPE`, `GUSTO`, `SHOPIFY`, `SQUARE`, `RUTTER`,
          `UBER`, `MOOV`, `QUALPAY`, `MANUAL_ENTRY`, `PARTNER_IMPLEMENTATION`, `QBO`, `XERO`, `FRESHBOOKS`.
        </ParamField>
      </Expandable>
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="replace" type="boolean">
  Whether or not the provided options should fully replace the currently set options. Disables option merging.
</ResponseField>


# Tight Embeddable UI
Source: https://docs.tight.com/embeddable-ui/tight-embeddable-ui

Embed modern, flexible, and performance-optimized accounting components

<Tip>You can simply link this doc to your orchestration agent to embed Tight's UI into your platform overnight. </Tip>

<img alt="Transaction Dashboard Demo" />

## Flexible embed options

<CardGroup>
  <Card title="Embed using AI (MCP)" icon="sparkles" href="/ai/mcp-tools/embedding-and-integration-mcp">
    Connect Tight's MCP Server to your dev workflow to embed overnight
  </Card>

  <Card title="React Components" icon="react" href="/embeddable-ui/react/patterns/embedding">
    Embed fully-responsive components into your React app
  </Card>

  <Card title="React Native Components" icon="mobile-screen" href="/embeddable-ui/react-native/patterns/embedding">
    Embed mobile-first features like mileage tracking using React Native
  </Card>

  <Card title="Javascript SDK" icon="js" href="/embeddable-ui/plain-js/patterns/embedding">
    Explore the Tight Embedded UX in the Playground
  </Card>

  <Card title="Ready-to-Launch App" icon="rocket-launch" href="/guides/launch-paths/ready-to-launch">
    Launch without development via a simple DNS configuration
  </Card>

  <Card title="Explore the Playground" icon="umbrella-beach" href="/playground">
    Explore the Tight Embedded UX in the Playground
  </Card>
</CardGroup>

## Modern design philosophy

Tight's embeddable components are designed to be customized to fit into *your* platform such that your users would never know they were created by a third party. There are a few different approaches to nailing your UI design:

1. Tight can do the white labelling design and implementation for you (see some [example white-labellings of popular SaaS platforms](/embeddable-ui/tight-embeddable-ui#custom-white-labellings) below). Simply send Tight's design team your Figma design system or send Tight a demo account login to your platform.
2. Or, you can utilize [Tight's innovative design token system](/embeddable-ui/react/reference/design-tokens) to override via CSS

## Custom white-labellings

<img alt="Desktop Financial Overview for Popular Payroll Provider" />

<div>
  <img alt="Mobile Financial Overview for Popular Payroll Provider" />

  <img alt="Mobile Expense Dashboard for Popular Payroll Provider" />

  <img alt="Desktop Transactions Dashboard for Popular Restaurant VSaaS" />
</div>


# Audit Trail
Source: https://docs.tight.com/guides/bookkeepers/audit-trail

Enterprise audit trail functionality ensuring robust change management

## Overview

Tight's Audit Trail automatically tracks *every* modification to *every* entity, creating an immutable record of who
changed what, when, and through which channel. This audit trail is kept up to date without any development work required
from your team.

The audit trail captures changes at the field level across all entity types: bank transactions, invoices, manual journal
entries, general ledger accounts, and more. Each revision includes the editor's identity, timestamp, and source of the
change.

## Importance of an Audit Trail

### Building confidence

For platforms serving business owners, audit trail functionality is a necessity. The ability to answer "Who changed this
and when?" is fundamental to building trust with business owners who demand financial accountability. Business owners
expect the ability to roll back changes and revert to an earlier revision of any transaction or entity, similar to what
users see in Google Docs and other popular tools. Tight tracks changes at the field level, not just the entity level,
and allows easy rollbacks.

### Preparing for audits

For platforms serving enterprises, maintaining data integrity and accountability is paramount during investigations
or audits.

### Checks and Balances

In professional bookkeeping workflows, multiple stakeholders interact with the same financial data. Business owners
create invoices, bookkeepers adjust transactions, and accountants perform closings. Tight's audit trail creates
natural accountability by making every action visible and attributable to a specific person.

## Use Cases

### Transaction auditing

Review the complete history of a specific transaction to understand how it evolved. On any given transaction, a business
owner may want to look at the categorization history, application of rules, matching to other entities, and any
bookkeeper edits. Additionally, if the business owner doesn't agree with a bookkeeper edit, or vice versa, they might
decide to restore an earlier version of the given transaction. Learn how
to [audit an entity](/api-reference/audit-trail#audit-an-entity).

### Company auditing

Bookkeepers commonly need to review all changes made to a company's books within a specific time period, pulling up the
past 30 days to see which transactions were recategorized, which invoices were edited, and which manual journal entries
were created. The [full audit trail](/api-reference/audit-trail#review-the-full-audit-trail) provides this complete
picture of accounting activity without requiring checking each transaction individually.

### Bookkeeper auditing

For bookkeeping firms managing multiple clients or platforms with assisted bookkeeping services, you can
[audit a specific editor](/api-reference/audit-trail#audit-a-specific-editor) to see changes made by a particular
bookkeeper across all their client companies. This cross-company view provides valuable insights into bookkeeper
activity and quality.


# Monthly/Annual Closings
Source: https://docs.tight.com/guides/bookkeepers/closings-and-monthly-reconciliations

Deliver closings accurately and efficiently via contextual collaboration

## Overview

As the [core system for managing your bookkeeping client companies](/guides/bookkeepers/companies), Tight's Bookkeeping
platform is
specifically designed to minimize the resources required to perform closings (aka reconciliations) and deliver monthly
financial summaries, including optimizing the formerly painstaking process of gathering necessary information from
the business owners.

## Use Cases

### Input from the business owner

Obtaining time-sensitive information from business owners is often a bottleneck for bookkeepers to perform closings.
When additional context is needed to classify or reconcile transactions, Tight enables bookkeepers to start
conversations directly on specific bank transactions. Business owners are notified via SMS, email, or your platform’s
notification system, and can respond from the [Financial Overview](/embeddable-ui/react/financial-overview)
with explanations or attachments. This contextual, transaction-level collaboration minimizes follow-ups and keeps
closings moving without requiring bookkeepers to leave their daily workflow.

### Monthly Closings

#### Ongoing reconciliation

While many accounting platforms still
require [legacy manual bank reconciliation processes](/guides/bookkeepers/closings-and-monthly-reconciliations#legacy-bank-reconciliations),
Tight embraces the new era of ongoing reconciliation. Tight automatically pulls bank account balances on an ongoing
basis and validates against corresponding General Ledger balances to detect discrepancies. When discrepancies are
detected, Tight automatically flags the affected bank account so the bookkeeper can address issues as they arise. In
most cases, where discrepancies do not arise, the bookkeeper is no longer required to do any manual labor.

This approach allows bookkeepers to maintain accurate books throughout the month instead of back-loading
reconciliation work at month's end. At the end of the month, Tight automatically ingests bank statements and creates
a monthly closing for each bank account. If the General Ledger balance matches the statement balance, the monthly
closing is automatically reconciled, minimizing manual effort for the bookkeeper.

#### Legacy bank reconciliations

For bookkeepers that prefer going through the popularized legacy reconciliation method of going through transactions line
by line, Tight's Bank Reconciliation UX requires zero learning curve for bookkeepers familiar with legacy accounting
platforms like QBO or Xero. Tight enhances this experience by automatically pulling bank statements via its banking
integrations where possible. When not possible, bookkeepers can upload bank statements for a given period and then move
forward validating that the transactions in that period match those in the bank statement.

#### Delivering the monthly summary

Once all bank accounts are reconciled for the month, bookkeepers can easily deliver a monthly financial summary for
business owner review. Business owners access the summary from the
[Financial Overview](/embeddable-ui/react/financial-overview), where they can review finalized
financials in a read-only experience.

Business owners can open a conversation directly on the monthly summary, enabling business owners to ask questions or
discuss the books with their bookkeeper in a single, contextual workflow.

### Annual Closings

At the end of the year, Tight automatically creates an annual closing entry to close out the prior year's Profit & Loss
activity and prepare the books for the new fiscal year. Once a year is closed, books can be locked to prevent any
further changes. Bookkeepers, provided they have the
correct [permissions](/guides/bookkeepers/team-management#set-permissions), are able to reopen closed years to make
adjustments as needed.


# Company Management
Source: https://docs.tight.com/guides/bookkeepers/companies

Onboard, migrate, manage, and perform bulk actions for/across your bookkeeping client companies

## Overview

Tight's Bookkeeping platform can be used to run the core of your bookkeeping operation, making it easy for you to manage
all of your clients (Companies), without having to dedicate resources to build a back-end dashboard for your bookkeepers
to provide service through.

## Use Cases

### Onboard client companies

#### Provision companies

You can invite your clients and configure their company directly from Tight's bookkeeping platform. When creating the
company, you select their Business Type, which determines their transaction categories and default rules, their Entity
Type which impacts their tax forms and tax estimates, and lastly their Chart of Accounts template. These selections
allow you to cater to each of your individual client's needs by customizing the system's behavior based on their
specific use cases.

<Tip>You can [provision companies directly via API](/api-reference/company-management/create-a-company) if you prefer to
manage onboarding from your own platform.</Tip>

Newly provisioned companies will receive an email with a link to directly access their new
[Financial Overview](/embeddable-ui/react/financial-overview).

#### Migrate from QuickBooks Online

62% of small businesses use nothing or spreadsheets to track their accounting, representing a massive opportunity for
you to onboard companies onto *your* accounting platform. For the remaining 38% of small businesses that use accounting
software already, they will be prompted to connect their existing Quickbooks Online (or Xero, Wave or Bench) account to
automatically sync their existing accounting data for a seamless transition.

#### Link bank accounts

Once their legacy accounting platform is connected (if applicable), your clients will also be prompted to link their
bank accounts,
credit cards, and any other
of [the many native integrations that Tight supports out of the box](/integrations/native-integrations).

### Review necessary transactions

Now that your clients have connected all of their data sources, all of their transactions will be automatically
categorized and reconciled by
[Tight's self-learning categorization algorithms](/ai/categorization/self-learning-transaction-categorization-overview).
The few transactions that Tight is not able to automatically reconcile will be automatically flagged to you in
the [Accountant Bank Transactions Dashboard](/embeddable-ui/react/accountant/transactions-dashboard) where you can
review them in bulk across all of your clients or filtered down to similar companies based on Business Type or their
specific Chart of Accounts template.

In the same vein as reviewing transactions across similar companies, Tight's bookkeeping platform
provides a [reconciliation dashboard](/embeddable-ui/react/accountant/reconciliation-dashboard) where you can review
and create [monthly and annual reconciliations](/guides/bookkeepers/closings-and-monthly-reconciliations) across
companies. Tight automatically pulls the bank statements from the underlying institutions when they are available and
gets the reconciliation started so that you don't need to wait for your clients to provide statements.

### Monitor bank connection health

In addition to flagging the transactions that require your attention, Tight also automatically pulls bank account
balances and flags these when there are discrepancies with the balances in the General Ledger. This on-going status
check allows you to front-load your reconciliation work when needed instead of waiting for the end-of-month closing
process. As part of this experience, Tight provides cross-cutting health-checks across all bank connections in the Tight
system, giving you a centralized place to review bank connection issues. Whether there's an outage at a given bank or a
specific client simply needs to relink their bank, Tight's Bookkeeping platform enables you to proactively identify
issues and address them with your clients.


# Team Management
Source: https://docs.tight.com/guides/bookkeepers/team-management

Administrate your bookkeeping team with checks and balances

## Overview

Tight's Bookkeeping platform can be used to run the core of your bookkeeping operation, making it easy for you to manage
your team of bookkeepers, without having to dedicate resources to build a back-end dashboard to manage the bookkeepers
and their permissions.

## Use Cases

### Onboard bookkeepers

Tight allows you to scale your bookkeeping team quickly without building custom user management infrastructure.
Bookkeepers in Tight, provided they have the correct [permissions](#set-permissions), are able to onboard other
bookkeepers directly from Tight's bookkeeper dashboard. Once added, new bookkeepers will receive an email providing
access to their new bookkeeping platform.

<Tip>You can [provision bookkeepers directly via API](/api-reference/bookkeepers/save-bookkeepers) if you prefer to
manage access from your own internal platform.</Tip>

### Set permissions

As your bookkeeping team grows, you will need to ensure bookkeepers only access the functionality their role requires to
prevent unauthorized changes. Bookkeepers in Tight have one of the following four roles:

1. Support: read-only access to all companies
2. Bookkeeper: read and write access to all companies
3. Accountant: same as Bookkeeper plus the ability to lock/unlock books
4. Admin: same as Accountant plus the ability to manage teammates

### Audit a bookkeeper

Performing quality checks and validating changes to books is essential to any bookkeeping operation.
Tight’s [Audit Trail](/guides/bookkeepers/audit-trail) allows you
to [audit a specific bookkeeper](/api-reference/audit-trail#audit-a-specific-editor) to see all changes made by that
bookkeeper across all their client companies. This cross-company view provides valuable insights into bookkeeper
activity and quality.


# Bank Transactions
Source: https://docs.tight.com/guides/business-owners/bank-transactions

Over 40M dollars & 100k unique transactions tracked per day using Tight

## Overview

Business owners have a varying amount of accounting knowledge, and even those with accounting skills don't
have time to look at a long list of transactions. Tight's proven, holistic transaction experience is built around the
core principle of being **easy to use for business owners**, as highlighted by the following characteristics:

1. Tight highlights only the small subset of transactions that actually require the business owner's attention.
2. All transaction categories are specific to the owner's business type.
3. The ["Invisible" double-entry General Ledger](/guides/business-owners/general-ledger) is kept behind-the-scenes.
4. Business owners still receive the robust financial statements only possible with complex double-entry accounting.
5. Tight's [categorization engine](/ai/categorization/self-learning-transaction-categorization-overview) learns from
   user actions and automatically reconciles transactions across all of the business owner's data sources (e.g. invoices
   and payroll runs), eliminating work that is otherwise manual and ongoing for your users.

<Tip>Bookkeepers also receive their own separate UX, allowing Tight to provide an easy-to-use experience to business owners
*as well as* a more advanced experience for bookkeepers, including manual journal entry creation and Bank Reconciliation
UXes that ease their transition from popular legacy accounting platforms.</Tip>

## Use Cases

### Expense Tracking

While collecting money (e.g. invoicing) is typically the first step in a business owner's accounting journey, the second
step is tracking expenses, *prior* to looking for a full-blown accounting system.

#### Automatic categorization

Tight's [AI-powered categorization](/ai/categorization/self-learning-transaction-categorization-overview) automatically
categorizes all transactions, leveraging each user's [business type](/api-reference/templates/get-business-types) to
provide categorizations specific to the user's business. For example, a flooring business may have a category for "Job
Site Measurement Tools", while a creator business may have a category for "Content Props". The engine continues to learn
from the behaviors of the 1.3M+ SMBs and 3k+ bookkeepers that have used Tight to categorize their transactions.

#### Decommingling for self-employed

The vast majority of self-employed individuals commingle their business and personal finances. Tight's in-house tax
calculation engine takes into account best practices for the given business type to predict which expenses are likely to
be deductible.

For example, an Uber driver's car wash expense is classified as a "Car Wash" (business expense), but the same
transaction is treated as personal for a graphic designer.

<Tip>Bank accounts and credit cards can be specified as business or personal accounts, informing whether the
decommingling UX is applicable.</Tip>

#### Expense Reporting

Simply embed the [Expense Dashboard](/embeddable-ui/plain-js/pages/bank-transactions/expense-dashboard) to provide your
users with a complete expense tracking experience. By simply linking bank accounts through your
preferred [banking integration](/integrations/banking), they'll receive
robust [expense reporting](/guides/business-owners/financial-statements#expense-reports) while only needing to review a
small subset of transactions that Tight flags for their review.

### Invisible double-entry accounting

Every bank transaction automatically generates double entries in Tight's General Ledger, allowing the business owner to
graduate to full accounting functionality if and when they need it.

This behind-the-scenes General Ledger enables your users to access
accurate [financial statements](/guides/business-owners/financial-statements), [tax estimates](/embeddable-ui/react/income-tax-dashboard),
and [business intelligence](/embeddable-ui/react/financial-overview) by simply linking their bank accounts.

All updates to transactions automatically update the GL and [Audit Trail](/guides/bookkeepers/audit-trail).
<Tip>Tight fully supports and automates the accrual basis, cash basis, and modified cash basis methodologies.</Tip>

### Automated reconciliation

As a user's business gets more and more complex, the amount of complexity in "reconciling" their books increases. Tight
automatically matches and reconciles transactions, eliminating manual reconciliation work for your users. For example,
Tight automatically
reconciles [payments and payouts to invoices](/guides/business-owners/invoicing#automatic-payment/payout-reconciliation), [payroll runs to their withdrawals](/guides/business-owners/payroll#automatic-payroll/withdrawal-reconciliation), [payments to bills](/guides/business-owners/bills#automatic-bill-payment-reconciliation),
bank transfer deposits to withdrawals, and income/expense refunds to their originating transactions.

This automatic reconciliation ensures that every bank transaction is properly accounted for without any manual user
input. Complex transactions like payment processor payouts are automatically nested to show the underlying invoices,
fees, and net amounts in a clear, organized view, demystifying what is otherwise an arduous, manual reconciliation
process.


# Bills (A/P)
Source: https://docs.tight.com/guides/business-owners/bills

Track bills and automatically reconcile bill payments

## Overview

Tight's bill payment experience makes it easy for you to provide your users with a full-featured bill management
experience, enabling them to create, review, and pay their bills directly in your platform.

Tight automatically reconciles bills, payments, and the associated (and often batched) bank withdrawals, while
maintaining the full double-entry General Ledger under the hood. That results in your users receiving real-time
accounting on all of their payable activity without any manual reconciliation.

By leveraging Tight's [native payment processor integrations](/integrations/payment-processing), you can enable your
users to pay their bills directly in your platform.

<Tip>When using any of Tight's native payment processor integrations, you own the relationship between your end users
and the provider, including any associated economic benefits.</Tip>

For platforms that already offer a full bill pay experience, a [custom integration](/integrations/custom-integrations)
with Tight enables all of the above functionality without altering your existing user flows.

## Use cases

### Adding bills to your platform

If your platform doesn't already offer bill management, you can embed the [Bill Dashboard](/embeddable-ui/react/bills/bill-dashboard) to add full-featured bill management into your
platform. Your users can create bills, manage vendors, process/track payments and fees, and have all the accounting automatically handled in the background.

### Adding payment processing

If you already have bill management in your product but want to add payment processing capabilities,
Tight's [native payment processor integrations](/integrations/payment-processing) enable you to add this functionality
without building any UI yourself. Your users can pay bills via ACH, wire transfer, or credit card, and Tight will
automatically:

* Match payments to bills
* Track payment processing fees as expenses
* Reconcile the payments against bank withdrawals
* Update accounting entries in real-time

### Automatic bill payment reconciliation

If your platform already offers both bill management and payment processing but lacks automated accounting
capabilities, you can sync your bill and payment data directly to the Tight API to enable automatic bill payment
reconciliation.

#### Bill Payment Example

Here's a concrete example of what Tight automates:

1. The business owner receives 4 bills from 4 vendors for \$300 each (\$1,200 total).
2. The business owner processes payment for all 4 bills via ACH. The payment processor charges \$2 per transaction (\$8
   in total fees).
3. The bank account shows a total withdrawal of \$1,208 (\$1,200 in vendor payments plus \$8 in processing fees).
4. The Tight API automatically matches the 4 bills with the bank withdrawal, creates expenses for the payment processing
   fees, and reconciles the total amount to the bank withdrawal. Furthermore, the Tight Embedded experience nests these
   transaction line items neatly under a single withdrawal row, giving the business owner complete visibility into their
   bill payments and fees without manual reconciliation work.


# Bookkeeping
Source: https://docs.tight.com/guides/business-owners/bookkeeping

Trusted by over 3k bookkeepers, Tight's Bookkeeper UX is the OS powering modern virtual bookkeeping

## Overview

Tight's Virtual Bookkeeping platform can be used to run the core of your bookkeeping operation, making it easy for you to offer your own Virtual Bookkeeping service, without having to dedicate resources to build:

* A seamlessly integrated back-end dashboard for your bookkeepers to provide service through
* A custom branded client-facing interface for:
  * Onboarding
  * Viewing reporting and metrics
  * Answering questions from the bookkeeper

## Use cases

### Your team's operating system

* Bookkeeping team management, including permissioning
* Tasks, including pending monthly/annual closings and reconciliations
* Communication workflow with business owners, including:
  * Streamlined onboarding interactions, including accounting migrations and smart bank linkage
  * Ability to mark transactions as needing business owner review
  * Transaction-level conversations
* Ability to perform operations across all businesses on your platform
* Ability to augment platform-level transaction rules

### Provide human-assisted bookkeeping without hiring humans

Through the many virtual bookkeeping operations using Tight as its OS, Tight
offers [human-assisted bookkeeping](/guides/solutions/dfy) to platforms that would like to offer this service without
hiring bookkeepers of their own.


# Data Lakes
Source: https://docs.tight.com/guides/business-owners/data-lakes

Enable your data scientists to work in the tools and format they love

## Overview

If your platform has built a bespoke analytics/reporting solution or envisions various proprietary use cases for large
analytical/accounting data, Tight's Data Lakes product is a natural add-on.

Of course, Tight allows you to access all the data that is available for your users in the API. But, Tight takes this
concept several levels further by periodically uploading raw data to your own data lake buckets, in the format your team
desires. By pushing that data into the warehouse of your preference, Tight eliminates the need for your data team to
build direct connections to the Tight API, allowing your team to work in the data stack that they are used to.

## Use cases

### Loan decisioning

For platforms offering lending products, Tight's Data Lakes provide the comprehensive financial data needed for
sophisticated underwriting and risk assessment. By automatically syncing transaction history, bank balances, invoice
data, and categorized expenses to your data warehouse, your credit team can build robust models without requiring manual
data uploads from applicants.

Your data scientists can work directly in tools like Snowflake, BigQuery, or your preferred analytics platform to
analyze cash flow patterns, revenue trends, expense ratios, and business health indicators. This eliminates the friction
of API calls for large datasets and enables complex joins with your existing customer data, application information, and
third-party data sources.

The result is faster loan decisions with better risk assessment. Your team can instantly evaluate an applicant's revenue
consistency, expense management, and overall financial trajectory, all from data that's already flowing into your
warehouse in a format your team knows how to work with.

### User/product analytics

Understanding how your users engage with accounting features is critical for product optimization, but pulling this data
through API calls doesn't scale for analytics workloads. Tight's [Lifecycle Event](/guides/business-owners/lifecycle-event-dictionary) uploads
to [Amplitude](/integrations/analytics/amplitude), [Mixpanel](/integrations/analytics/mixpanel),
or [Intercom](/integrations/customer-service/intercom) provide automatic event tracking for all user actions within
Tight's embedded experiences.

Every transaction categorization, invoice creation, bank connection, report generation, and dashboard view is captured
as structured event data. Your product team can analyze activation funnels, feature adoption, and user retention
patterns without building instrumentation infrastructure. Which features drive engagement? Where do users get stuck
during onboarding? How does accounting feature usage correlate with overall platform retention?

For platforms with bespoke analytics needs, full Data Lake uploads provide the raw material for custom analysis. Join
accounting activity data with your proprietary user data to understand financial behaviors across segments, build
predictive models for churn, or identify expansion opportunities based on accounting sophistication.

## Data types

Tight will upload data related to the following elements of Tight API/SDK information and interactions on daily, weekly,
or monthly intervals:

### Bank linkage

A [Parquet file](https://parquet.apache.org/) containing information on all linked bank accounts. The columns include
the bulk of data available in the [/banks/accounts endpoint](/v5.0/api-reference/banks/get-bank-accounts), including `userId`,
`apiInstitutionId`, `apiAccountNo`, `apiAccountType`, `createdDate`, `lastExpenseSyncedDate`, `lastRevenueSyncedDate`,
`apiCurrentBalance`, and more. Each file contains all the records that were updated since the last data upload.

### Invoices

A [Parquet file](https://parquet.apache.org/) containing information on all invoices. The columns include the bulk of
data available in the [/invoices endpoint](/reference/getinvoices), including `userId`, `date`, `totalAmount`,
`dueDate`, `sentDate`, `lastViewedDate`, `status`, and more. Each file contains all the records that were updated since
the last data upload.

### Lifecycle Events

A folder of [Parquet files](https://parquet.apache.org/), one per event category, containing information on actions each
user has taken, which is often useful for optimizing user experiences/funnels. The columns include `userId`, `date`,
`event`, and event-specific metadata. The full list of events being tracked is available in
the [Lifecycle Event Dictionary](/guides/business-owners/lifecycle-event-dictionary).

### Transactions

A [Parquet file](https://parquet.apache.org/) containing information on all transactions. The columns include the bulk
of data available in the [/transactions endpoint](/v5.0/api-reference/banks/get-transactions), including `userId`,
`apiInstitutionId`, `apiAccountNo`, `date`, `amount`, `bankDescription`, `categoryName`, and more. Each file contains
all the records that were updated since the last data upload.

## Integrations

Tight currently supports native integrations for full Data Lake uploads to:

* [Amazon S3](/integrations/analytics/amazon-s3)
* [Google Cloud Storage](/integrations/analytics/google-cloud-storage)
* [Snowflake](/integrations/analytics/snowflake)

Additionally, Tight natively supports Lifecycle Event uploads to:

* [Amplitude](/integrations/analytics/amplitude)
* [Intercom](/integrations/customer-service/intercom)
* [Mixpanel](/integrations/analytics/mixpanel)


# Dimensions
Source: https://docs.tight.com/guides/business-owners/dimensions

Track profitability across multiple dimensions

## Overview

Many businesses need to track profitability across multiple dimensions beyond just account categories, e.g. by location,
job code, product line, project, or department. Tight's dimensions functionality is a major improvement on class
tracking functionality offered by legacy accounting providers, enabling multi-dimensional reporting without requiring
your users to maintain complex account structures.

Your platform can define the dimensions (including hierarchies) made available to the businesses on your platform, and
the businesses can define the values against those dimensions. Your users can assign dimensions to transactions,
invoices,
and expenses, then generate Profit & Loss reports segmented by dimension to understand which locations, products, or
projects are most profitable. This is particularly valuable for platforms serving multi-location businesses,
project-based services, or any vertical where profitability analysis by segment drives business decisions.

The dimension tracking integrates seamlessly with Tight's accounting engine, so businesses get accurate profitability
reporting by segment while maintaining a clean, simple Chart of Accounts structure.

## Use Cases

### Platform defines dimensions

Your platform defines the dimensions that businesses on your platform can use to label their transactions. These labels
serve as the framework for multi-dimensional reporting (e.g., Region, Location, Department). By standardizing these
dimensions at the platform level, you create vertical-specific tracking capabilities that align with your users'
business models.

For example, a construction platform might define labels like "Project," "Phase," and "Job Type," while a retail
platform might define "Location," "Product Category," and "Sales Channel." Once you define these labels through
the [dimensions API](/api-reference/templates/save-dimensions), all businesses on your platform can
populate their own specific values under each label dimension.

This approach gives you control over the reporting structure while giving your users flexibility in how they apply it.
Dimensions can be hierarchical, allowing for nested categorization (e.g., Region → Location → Department).

<Tip>The Tight API lets you define which labels are required, enforcing consistency across your platform's data</Tip>

### Businesses set dimension values

Once you've defined the dimensions at the platform level, individual businesses populate those labels with
their own specific values. These business-level dimension values represent the actual categories each business uses for
tracking against a given dimension (e.g., under "Location": "NYC Office," "SF Office," "Remote"; under "Department": "
Sales," "Marketing," "
Operations").

Your platform may already track these segments, in which case you can simply have your system push them to
the [dimensions API](/api-reference/dimensions/save-dimension-values). Once created, these segments can be
assigned to transactions, invoices, expenses, bills, and mileage entries. When your users generate financial reports,
they can filter and/or group by any dimension to see profitability broken down by those dimensions, all without
creating separate accounts for each segment.

This gives each business complete flexibility to organize their financial data according to their unique structure,
while your platform maintains consistent reporting capabilities across all businesses.

## Examples

### Toast: Locations, Revenue Centers

Toast is a restaurant management platform that helps food and beverage businesses run operations like ordering,
payments, and reporting from a single system. Toast tracks operations across Locations (the physical restaurant),
Revenue Centers (sub-location groupings like dine-in, bar, patio, or online ordering), Service Periods (breakfast,
lunch, dinner), Order Channels (in-person, delivery platforms, kiosk), and Employees. Together, these dimensions let
restaurant operators understand which parts of their business - which location, which revenue stream, which daypart -
are driving performance.

With Tight embedded into Toast, Toast operators could slice financial reporting across any combination of these
dimensions, e.g., comparing net profit by Revenue Center within a Location, or rolling up P\&L by Service Period across
all
locations. Because Tight would mirror Toast's native dimension structure, operators could get accurate financial
reporting by segment without maintaining a separate Chart of Accounts for each one.

#### Toast Platform Setup

Toast defines the following dimensions at the platform-level:

* **Dimension 1:** Location
* **Dimension 2:** Revenue Center

#### Restaurant Configuration

Toast pushes the existing business configuration from its system into the Tight API. For example, a restaurant group
with 4 locations across two cities creates specific dimension values:

* **Dimension 1:** Location

* **Dimension 1 Values:**
  * Georgetown DC
  * Dupont Circle DC
  * Back Bay Boston
  * South End Boston
  * Mission SF
  * SoMa SF

* **Dimension 2**: Revenue Center

* **Dimension 2 Values**:
  * Dine-In
  * Bar
  * Online Ordering
  * Catering

#### Transaction Tagging

When transactions are ingested, e.g. food costs, beverage purchases, delivery commissions, staff
wages, users can tag each to a Location and/or Revenue Center.
<Tip>Tight learns these behaviors
and [creates rules to automate these tagging behaviors](/ai/categorization/self-learning-transaction-categorization-overview#rule-insertion-flow)</Tip>

#### Restaurant Reporting Outcome

The owner can generate P\&L reports to understand performance:

* Group by Location to compare total profitability across all locations
* Group by Revenue Center to see whether Dine-In or Online Ordering drives better margins
* Filter by both Location and Revenue Center to isolate specific operations (e.g., just Bar revenue at Dupont Circle DC)

### ServiceTitan: BUs, Trades, Divisions

ServiceTitan is a trades management platform that helps home and commercial service businesses run operations like
scheduling, dispatching, invoicing, and reporting from a single system. ServiceTitan tracks operations across Business
Units (the primary organizational unit, e.g. "HVAC Service" or "Plumbing Install"), Trades (the type of trade, e.g.
HVAC, Plumbing, Electrical), Divisions (the type of work within a trade, e.g. Install, Service, Maintenance), Zones (
geographic service areas within a Business Unit), and Job Types (e.g. Service, Estimate, Warranty). Together, these
dimensions let trades businesses understand which parts of their operation - which trade, which division, which service
area - are driving performance.

With Tight embedded into ServiceTitan, ServiceTitan operators could slice financial reporting across any combination of
these dimensions, e.g., comparing net profit by Division within a Business Unit, or rolling up P\&L by Trade across all
zones. Because Tight would mirror ServiceTitan's native dimension structure, operators could get accurate financial
reporting by segment without maintaining a separate Chart of Accounts for each one.

#### ServiceTitan Platform Setup

ServiceTitan defines the following dimensions at the platform level:

* **Dimension 1:** Business Unit
* **Dimension 2:** Trade
* **Dimension 3:** Division

#### Trades Business Configuration

ServiceTitan pushes the existing business configuration from its system into the Tight API. For example, a multi-trade
contractor operating across two regions creates specific dimension values:

* **Dimension 1:** Business Unit

* **Dimension 1 Values:**
  * HVAC Install Residential
  * HVAC Service Residential
  * HVAC Maintenance Residential
  * Plumbing Install Residential
  * Plumbing Service Residential
  * Electrical Service Residential

* **Dimension 2:** Trade

* **Dimension 2 Values:**
  * HVAC
  * Plumbing
  * Electrical

* **Dimension 3:** Division

* **Dimension 3 Values:**
  * Install
  * Service
  * Maintenance

#### Transaction Tagging

When transactions are ingested, e.g. labor costs, material purchases, subcontractor invoices, equipment rentals, users
can tag each to a Business Unit, which is associated with a specific Trade and Division.

<Tip>Tight learns these behaviors
and [creates rules to automate these tagging behaviors](/ai/categorization/self-learning-transaction-categorization-overview#rule-insertion-flow)</Tip>

#### Trades Reporting Outcome

The owner can generate P\&L reports to understand performance:

* Group by Business Unit to compare total profitability across all departments
* Group by Trade to see whether HVAC or Plumbing drives better margins
* Filter by both Trade and Division to isolate specific operations (e.g., just HVAC Install profitability)

### Procore: Cost Codes, Cost Types

Procore is a construction management platform that helps general contractors, owners, and specialty contractors run
operations like project management, budgeting, procurement, and reporting from a single system. Procore tracks
operations across Cost Codes (the specific type of work being performed, aligned by default to the CSI MasterFormat,
e.g. Concrete, Framing, Electrical), Cost Types (the nature of the spend, e.g. Labor, Materials, Equipment,
Subcontracts), Sub Jobs (subdivisions of a project, e.g. a building within a campus or a phase of work), and
Portfolio-level dimensions including Project Type (e.g. Ground-Up, Renovation), Department, Office, and Program (a
grouping of related projects). Together, these dimensions let construction businesses understand which parts of their
operation - which project, which cost category, which office - are driving performance.

With Tight embedded into Procore, Procore operators could slice financial reporting across any combination of these
dimensions, e.g., comparing net profit by Cost Type within a Cost Code, or rolling up P\&L by Office across all active
projects. Because Tight would mirror Procore's native dimension structure, operators could get accurate financial
reporting by segment without maintaining a separate Chart of Accounts for each one.

#### Procore Platform Setup

Procore defines the following dimensions at the platform level:

* **Dimension 1:** Cost Code
* **Dimension 2:** Cost Type
* **Dimension 3:** Sub Job

#### GC Configuration

Procore pushes the existing business configuration from its system into the Tight API. For example, a general contractor
working on a large mixed-use development creates specific dimension values:

* **Dimension 1:** Cost Code

* **Dimension 1 Values:**
  * 03-000 Concrete
  * 06-000 Framing & Rough Carpentry
  * 16-000 Electrical
  * 22-000 Plumbing
  * 09-000 Finishes

* **Dimension 2:** Cost Type

* **Dimension 2 Values:**
  * Labor
  * Materials
  * Equipment
  * Subcontracts

* **Dimension 3:** Sub Job

* **Dimension 3 Values:**
  * Building A
  * Building B
  * Site Work
  * Common Areas

#### Transaction Tagging

When transactions are ingested, e.g. subcontractor invoices, material purchases, equipment rentals, labor timecards,
users can tag each to a Cost Code and Cost Type, with Sub Job added when phase- or building-level detail is needed.

<Tip>Tight learns these behaviors
and [creates rules to automate these tagging behaviors](/ai/categorization/self-learning-transaction-categorization-overview#rule-insertion-flow)</Tip>

#### GC Reporting Outcome

The owner can generate P\&L reports to understand performance:

* Group by Cost Code to compare spend across all work types on a project
* Group by Cost Type to see whether Labor or Subcontracts are the dominant cost driver
* Filter by both Cost Code and Sub Job to isolate specific operations (e.g., just Electrical costs for Building A)


# Financial Statements
Source: https://docs.tight.com/guides/business-owners/financial-statements

Unlock robust financial reporting for your user base

## Overview

Whether or not you are leveraging one of [Tight's native integrations](/integrations/native-integrations), Tight
automatically keeps a double-entry [General Ledger](/embeddable-ui/react/accounting/general-ledger) behind the scenes for all of your users. While
your users may never want to look at a GL or [Chart of Accounts](/embeddable-ui/react/accounting/chart-of-accounts), the beauty of the
behind-the-scenes GL is that they get all the financial reporting that they could ever need, *without* the burden of
having to manage a General Ledger or understand bookkeeping.

## Interactive Drill-Downs

Every number on every financial report is clickable and drillable. When your users click on any line item, whether
it is "Services Income" for a specific month on the P\&L or all "Accounts Receivable" on the Balance Sheet, they
instantly see the underlying transactions that compose that figure.

This transparency builds trust in the numbers and enables self-service exploration. Business owners can answer their own
questions without needing to contact support or their bookkeeper. For bookkeepers working in your platform, these
drill-downs provide the audit trail needed for professional accounting work.

## Core Financial Statements

### [Balance Sheet](/embeddable-ui/react/financial-statements/balance-sheet)

### [Cash Flow Statement](/embeddable-ui/react/financial-statements/cash-flow-statement)

### [Profit & Loss (Income) Statement](/embeddable-ui/react/financial-statements/profit-loss-report)

### [Trial Balance](/embeddable-ui/react/financial-statements/trial-balance-report)

### Expense Reports

### Additional Reports

Tight provides [dozens of specialized reports](/embeddable-ui/plain-js/pages/financial-statements/report-dashboard)
beyond the core financial statements. These operational reports help your users make data-driven decisions without
leaving your platform:

**Common operational reports include:**

* Expenses by Vendor, Revenue by Customer
* Aged Accounts Receivable and Payable
* Transaction Detail exports for custom analysis
* Tax filing reports (Form 1040 Schedule C, Form 1065, Form 1120-S, Form 1120, and T2125)

**Customization capabilities:**
Every report supports filtering by date range, dimension, account type, and custom fields. Users can save custom report
configurations for recurring analysis. For platform-specific reporting needs, Tight's reporting engine can be extended
with custom report templates.

Direct API access to any and all accounting data is also available for building fully custom reports or integrations.

## Use cases

### Real-time Business Insights

All Tight financial reports update in real-time as transactions flow through the system; your users get instant
visibility into current financial performance. The real-time nature reduces support burden (users see accurate data
immediately) and enables your platform to become
the single source of truth for financial decision-making.

If desired, you can consume report data via JSON API to build custom visualizations like runway calculators, KPI
dashboards, or vertical-specific metrics.

### Dimensions

Tight's financial reports fully support [dimensions](/guides/business-owners/dimensions), enabling
multi-dimensional profitability analysis. Users can segment any financial report by location, product line, project, or
department to understand which parts of their business drive performance.

### AI CFO

Tight's [Financial Statements MCP tools](/ai/mcp-tools/financial-statements-mcp) enable AI assistants to access and
analyze financial reports through natural language. Your users can ask questions like "Show me our Q4 P\&L by department"
or "How has our cash position changed over the past year?" and get instant, accurate analysis powered by Tight's
real-time financial data.


# General Ledger
Source: https://docs.tight.com/guides/business-owners/general-ledger

Mature accounting functionality trusted by 3k+ bookkeepers

## Overview

As your user's data flows into Tight, Tight's behind-the-scenes double-entry accounting is enabled in the background.
Every expense, invoice, tax payment, bank transfer, bill, etc. has the proper accrual basis, cash basis, and modified
cash basis accounting transactions tracked in the background.

Unlike most accounting software products available today, the behind-the-scenes nature of this double-entry
accounting means that you can provide your users with all the robustness they need, without requiring your users to
understand accounting.

And, if you have power users (or bookkeepers) who want to get into the granularity
of [General Ledger (GL)](/embeddable-ui/react/accounting/general-ledger) transactions, including creating manual journal
entries, they can absolutely do so.

## What the General Ledger enables

### Financial Reporting

The double-entry General Ledger that Tight maintains automatically enables
comprehensive [financial reporting](/guides/business-owners/financial-statements) without requiring your users to
understand accounting mechanics. Every transaction that flows through your platform, whether it's an invoice,
bank transaction, bill, or payroll run, automatically updates the appropriate GL accounts in real-time.

This means your users get instant access
to [Profit & Loss statements](/embeddable-ui/react/financial-statements/profit-loss-report),
[Balance Sheets](/embeddable-ui/react/financial-statements/balance-sheet),
[Cash Flow Statements](/embeddable-ui/react/financial-statements/cash-flow-statement), and
[Trial Balance reports](/embeddable-ui/react/financial-statements/trial-balance-report) without manual bookkeeping work.

Bookkeepers and accountants working within your platform can drill down from any report line item directly into the
underlying transactions and journal entries, providing the audit trail and transparency needed for professional
accounting work.

### Automated reconciliation

Tight's accounting engine automatically handles the complex reconciliation scenarios that typically require manual
bookkeeping intervention. When a payment processor (
e.g. [Adyen](/integrations/payment-processing/adyen), [Stripe](/integrations/payment-processing/stripe)) payout hits a
business's bank account, Tight automatically matches it to the underlying invoices, merchant fees, and payment
processing charges without any manual matching required. See how this works in practice
with [automatic payment/payout reconciliation](/guides/business-owners/invoicing#automatic-paymentpayout-reconciliation).

The same automation applies
to [matching bill payments](/guides/business-owners/bills#adding-automatic-bill/withdrawal-reconciliation-to-your-existing-bill-pay),
bank transfers between
accounts, [payroll withdrawals](/guides/business-owners/payroll#automatic-payrollwithdrawal-reconciliation), and other
multi-leg transactions that traditionally create reconciliation headaches. Your users see clean, reconciled books
without needing to understand the accounting mechanics happening in the background.

### Dimension Tracking

Many businesses need to track profitability across multiple dimensions beyond just account categories, e.g. by location,
product line, project, or department. Tight's [dimensions](/guides/business-owners/dimensions) functionality
enables this multi-dimensional reporting without requiring your users to maintain complex account structures.

Your platform can define the dimension values and hierarchies made available to the business on your platform, and the
businesses can define the values against those dimensions. Your users can assign dimensions to transactions, invoices, and
expenses, then generate Profit & Loss reports segmented by dimension to understand which locations, products, or projects
are most profitable. This is particularly valuable for platforms serving multi-location businesses, project-based
services, or any vertical where profitability analysis by segment drives business decisions.

The dimension tracking integrates seamlessly with Tight's accounting engine, so businesses get accurate profitability
reporting by dimension while maintaining a clean, simple [Chart of Accounts](/guides/get-started/accounting-migrations/default-chart-of-accounts) structure.

## Use cases

### Augment Your Platform

If you already have invoicing, expense tracking, or bill pay built into your product, Tight's accounting engine can back
your existing features with proper double-entry bookkeeping. Push your existing transaction data to the Tight API, and
Tight automatically maintains the general ledger, enabling financial reporting and reconciliation capabilities you'd
otherwise need to build from scratch.

This approach lets you add complementary features selectively; see below for some example features you can add to your
platform with Tight:

1. [Expense Tracking](/guides/business-owners/bank-transactions#expense-tracking)
2. [Automatic Mileage Tracking](/guides/business-owners/mileage-tracking#automatic-mileage-tracking)
3. [Financial Statements](/guides/business-owners/financial-statements)
4. [Invoicing](/guides/business-owners/invoicing#adding-invoicing-to-your-platform)
5. [Bill Pay](/guides/business-owners/bills#adding-bills-into-your-platform)

### Turnkey Accounting Solution

The [Financial Overview](/embeddable-ui/react/financial-overview) provides a complete accounting platform
embedded directly in your product. Your users see a simplified, action-oriented view that surfaces only what requires
their attention — uncategorized transactions, unpaid invoices, upcoming tax deadlines — without overwhelming them with
accounting complexity.

Everything is included: bank connections, expense categorization, invoicing, financial statements, income tax estimates,
and reconciliation. Your users get professional-grade accounting functionality without needing to understand debits,
credits, or journal entries.

#### Advanced Accounting Controls

For bookkeepers and sophisticated business owners who need deeper control, embed individual accounting pages alongside
the dashboard. These users can access the [Chart of Accounts](/embeddable-ui/react/accounting/chart-of-accounts) to
customize account structures, the [General Ledger](/embeddable-ui/react/accounting/general-ledger) to review
transaction-level detail, and the [Journal](/embeddable-ui/react/accounting/journal) to create manual journal entries
for depreciation, amortization, or complex adjustments. This gives power users the granular control they expect while
keeping the experience simple for everyone else.


# Invoicing (A/R)
Source: https://docs.tight.com/guides/business-owners/invoicing

Over 20k invoices processed per month

## Overview

If Invoicing is not your product team's core competency, let Tight's proven invoicing platform handle the heavy lifting.

If you already have proven invoicing in your product, a [custom integration](/integrations/custom-integrations) with
Tight enables:

* Full double-entry accounting (accrual and cash basis)
* The ability to rapidly add a [payment processor of your choosing](/integrations/payment-processing) without building
  any UI
* Automatic [payment/payout reconciliation](/integrations/payment-processing/adyen#automated-reconciliation) against
  bank deposits

<Tip>When using one of Tight's native payment processor integrations, you own the relationship between your end users
and the provider, including any associated economic benefits. </Tip>

## Use cases

### Adding invoicing to your platform

If you don't already offer invoicing, you can embed Tight's complete invoicing experience directly into your platform.
Your users can create invoices, send them to clients, accept payments, and have all the accounting automatically handled
in the background.

Embed the [Invoice Dashboard](/embeddable-ui/react/invoicing/invoice-dashboard) to add full-featured invoicing to your
platform. Your users get a complete invoicing workflow, including branding customization, invoice creation, client management, payment tracking,
and automatic accounting, all within your product experience.

Once integrated with a payment processor (Stripe, Adyen, etc.), invoices include payment buttons that your users'
clients can use to pay directly. The [Customer-Facing Invoice](/embeddable-ui/react/invoicing/customer-facing-invoice)
component provides a polished payment experience that matches your end user's brand while Tight handles the payment
processing and accounting automatically.

### Adding payment processing to your existing invoicing

If you already have invoicing in your product but want to add payment processing capabilities,
Tight's [native payment processor integrations](/integrations/payment-processing) enable you to add this functionality
without building any UI yourself.

Integrate with payment processors
like [Stripe](/integrations/payment-processing/stripe), [Adyen](/integrations/payment-processing/adyen), or others, and
Tight handles the payment acceptance, fee tracking, and payout reconciliation automatically. Your users can accept
credit card or ACH payments on their invoices, and Tight will automatically:

* Match payments to invoices
* Track merchant fees as expenses
* Reconcile the payments against payouts
* Update accounting entries in real-time

This approach is ideal if you've already invested in invoicing infrastructure and want to add payment processing and
automatic reconciliation without rebuilding your invoicing experience.

### Automatic payment/payout reconciliation

If your platform already offers both invoicing and payment processing but lacks sophisticated accounting capabilities,
you can sync your invoice and payment data directly to the Tight API to enable automatic payment and payout
reconciliation.

Regardless of which approach you choose, embedding Tight's invoicing, integrating with Tight's payment processors, or
feeding your existing invoice and payment data directly to the Tight API, the automatic reconciliation works the same
way. Tight matches payments to invoices, tracks fees, reconciles payouts against bank deposits, and updates the general
ledger automatically, with zero user input required.

#### Invoice Payout Example

Here's a concrete example of what Tight automates:

1. The business owner sends out 4 \$1,000 invoices to 4 clients.
2. Those 4 invoices are paid via 4 separate credit card payments via Stripe. Stripe charges \$25 in merchant fees for
   each of the 4 invoices.
3. The user receives a payout from Stripe for \$3,890 (\$4,000 minus \$100 in merchant fees and minus a \$10
   contribution to Stripe Climate), also seen as a \$3,890 deposit into their checking account.
4. The Tight API automatically matches the 4 invoices with the one payout, creates expenses for the various merchant
   fees, and reconciles the net amount to the bank deposit. Furthermore, the Tight Embedded experience nests these
   transaction line items neatly under a single payout row, giving the business owner complete visibility into their
   invoice payments and fees without manual reconciliation work.

<Tip>Tight's automatic reconciliation works across all supported payment processors, including Stripe, Adyen, and others.
The same seamless experience applies regardless of which payment processor your users choose.</Tip>


# Migrations & Imports
Source: https://docs.tight.com/guides/business-owners/migrations-and-imports

Thousands of businesses migrated from QBO, Xero, Wave, and Bench

## Overview

While [independent research shows that 62% of small businesses don't use any accounting software yet](https://www.tight.com/embedded-accounting-smb-vertical-software-report),
leaving a major greenfield opportunity for your platform, Tight has successfully completed thousands of migrations
from legacy accounting platforms, including QuickBooks Online, Xero, Wave, and Bench.

This proven import functionality allows you to transfer a business's accounting data into your embedded accounting
platform,
preserving the business's historical financial information while ensuring data integrity throughout the migration
process.

Tight makes this easy for the business owner or the bookkeeper, allowing fully automated multiyear imports from several
legacy accounting providers, including:

* QuickBooks Online (QBO)
* Xero
* Wave
* Bench

The import process automatically maps and cleans up the business's Chart of Accounts, showing the changes made along the
way and allowing changes to be made in the process. The import process takes anywhere from 5 seconds to 3 minutes,
depending on how many years of data the user is migrating.

## Bulk migrations

When moving an entire user base from a legacy accounting platform onto Tight, it is much more efficient to import your
users' data programmatically. You can kick off the import to Tight with a single API request. The Tight API will alert
you via a Lifecycle Event Webhook as soon as the import is completed, at which point the Tight API makes the comparative
verification reports available via API.


# Mileage Tracking
Source: https://docs.tight.com/guides/business-owners/mileage-tracking

Over 1 million miles a day tracked using Tight

## Overview

Small business owners/operators (and their employees) who spend any amount of time driving for their business have
found that tracking mileage is both important and unbearable. The benefits of tracking mileage, both in order to
maximize tax deductions as well as for employee reimbursements, are immense, but the requirement to document each drive
is very cumbersome.

Tight provides multiple mechanisms for automatically tracking your users' mileage, removing the need for them to keep a
manual mileage log, and adding a daily use case to your product.

With over 1 billion miles tracked to date and 1 million miles tracked per day, Tight's mileage tracking is robust,
mature, and proven. And, it's all automatically tied into Tight tax estimates and Tight tax reporting.

## Use cases

### Business owner/operators

Business owners can reduce their taxable income by tracking and reporting the mileage they drove for business purposes;
this is commonly known as the mileage tax deduction. For example, real estate agents can generally deduct mileage driven
while taking buyer clients to see homes for sale; general contractors can generally deduct the mileage driven when going
to the client's site. This type of business mileage, when reported correctly, can lower the tax liability for the
business.

### Employee reimbursement

Some employers reimburse their employees for work-related mileage driven in their personal vehicle. For example, an
individual employed by a consulting firm (i.e. a consultant) might drive their personal vehicle to visit a client, and
the employer may offer reimbursement for that mileage driven. In order for the consultant to easily track that mileage
and submit it to their employer, the consultant likely uses an automated mileage tracker. Additionally, proper
documentation allows the firm itself to deduct the expenses associated with that mileage reimbursement.

## Tracking methods

### Automatic mileage tracking

Automatic mileage tracking is best for users whose daily driving is predominantly for business purposes. Tight's mobile
mileage tracking SDK automatically detects when the user is driving, without requiring input from the user.

<Tip>If your product stores addresses (e.g. job sites, client locations, properties under supervision, etc.), you can
programmatically push those into Tight so that any drives containing one of these locations are automatically marked as
business drives.</Tip>

The route they drove (including start and end addresses), distance driven, and deduction/reimbursement amount are
tracked without the user needing to remember to do anything. They simply need to enable automatic mileage tracking once
inside your mobile app. Simply implement the Tight iOS mileage tracking SDK, Android mileage tracking SDK,
and/or [React Native mileage tracking component](/embeddable-ui/react-native/mileage-dashboard) once, and rest assured
that annual OS updates (including permissioning and device-specific changes) will be taken care of for you.

### Semi-automatic mileage tracking

Semi-automatic mileage tracking is best for users whose daily driving is an even mix of business and personal driving.
Tight's mobile mileage tracking SDK allows your user to press a start (and stop) button to track specific drives.

The route they drove (including start and end addresses), distance driven, and deduction/reimbursement amount are
tracked at the touch of a button, without the user needing to input anything other than pressing start and stop.

### Manual mileage tracking

Manual mileage tracking is best for users who rarely drive for business purposes.
Tight's [web-based mileage tracking dashboard](/embeddable-ui/react/mileage-dashboard) allows your users to input the
start and end address of a business drive, at which point the route is back-calculated, along with the distance driven,
and deduction/reimbursement amount. The user can input any additional notes and/or assign the drive to a specific
client, for powerful client-specific reporting and/or for reimbursement from the client.


# Canadian Support
Source: https://docs.tight.com/guides/business-owners/multi-currency/canadian-accounting

Full native support for Canadian nuances, including input tax credit, provincial tax estimates, and more

## Overview

One size fits none when it comes to accounting, and that's why Tight has built native support for Canadian businesses.
Whether your user base resides solely in Canada or you're looking at adding Canadian support to your future roadmap
without dedicating development resources, Tight has you covered.

## Use cases

### Tax Estimates

Canadian users have to pay quarterly installments to the CRA, and Tight's [Tax Calculations API](/api-reference/tax-estimates/get-tax-estimates) makes it easy for you to provide your users with the income tax estimates needed to pay those installments.

Your users' [tax profiles](/api-reference/tax-profile/save-tax-profile) are formatted specifically for providing accurate Canadian estimates, including the following Canada-specific fields:

| Field | Description | Format |
| :- | :- | :- |
| federalFilingStatus | The [marital status](https://www.canada.ca/en/revenue-agency/services/tax/individuals/topics/about-your-tax-return/tax-return/completing-a-tax-return/personal-address-information/marital-status.html) of the user | Must be one of the following: "SINGLE", "MARRIED" |
| taxState | Two-letter province abbreviation | String |
| annualW2Income | Estimate of the user's annual wage total (aka T4 Income), before any tax withholdings | Numeric, with 2 decimal places |
| spouseIncome | Estimate of the user's spouse's annual wage total (aka T4 Income), before any tax withholdings | Numeric, with 2 decimal places |
| numDependents | Number of dependents | Numeric |
| dependentIncome | Estimate of the user's dependents' income | Numeric, with 2 decimal places |
| vehicleBusinessPercent | The user's estimated percentage of driving that was for business purposes (measured in km) | Numeric, with 2 decimal places |
| autoSalesTax | Whether the user wants the Tight API to automatically calculate sales tax, based on the province that each expense originated in. This is useful for calculating the input tax credit, which will be applied against any sales tax owed on business income. | Boolean |

Additionally, the [tax estimates](/api-reference/tax-estimates/get-tax-estimates) themselves are returned with different attributes that are specific to how taxes are calculated in Canada. The response from GET /estimates contains a Canada-specific JSON object, with a vast amount of useful tax information as follows:

```json theme={null}
{
  "country": "CAN",
  "state": "QC",
  "year": 2022,
  "t4Income": 100000.00,
  "t4FederalMarginalTaxRate": 20.50,
  "t4StateMarginalTaxRate": 25.75,
  "spouseIncome": 0.00,
  "dependentIncome": 0.00,
  "cppContributionAmount": 0.00,
  "cppDeductionAmount": 0.00,
  "qppContributionAmount": 1589.57,
  "qppDeductionAmount": 794.79,
  "businessIncome": 29346.73,
  "expenses": 7336.68,
  "deductibleNonMileageExpenses": 7336.68,
  "deductibleVehicleExpenses": 0.00,
  "adjustedGrossIncome": 22010.05,
  "taxableNetIncome": 22010.05,
  "overallTax": 10988.22,
  "overallTaxSavings": 3796.73,
  "overallTaxUnpaid": 0.00,
  "federalTaxUnpaid": 0.00,
  "stateTaxUnpaid": 0.00,
  "annualPaymentDueDate": "2023-06-15 00:00:00.000",
  "afterTaxIncome": 11021.83,
  "federalTax": {
    "taxableIncome": 22010.05,
    "marginalTaxRate": 26.0000,
    "taxCredit": 0.00,
    "taxAmountWithoutTaxCredit": 5701.05,
    "preCreditEffectiveTaxRate": 25.90,
    "effectiveTaxRateBeforeWithholding": 25.90,
    "taxBeforeWithholding": 5701.05,
    "withholdingAppliedToTax": 0.00,
    "taxAmount": 5701.05,
    "effectiveTaxRate": 25.90
  },
  "stateTax": {
    "taxableIncome": 22010.05,
    "marginalTaxRate": 25.7500,
    "taxCredit": 158.96,
    "taxAmountWithoutTaxCredit": 5446.13,
    "preCreditEffectiveTaxRate": 24.74,
    "effectiveTaxRateBeforeWithholding": 24.02,
    "taxBeforeWithholding": 5287.17,
    "withholdingAppliedToTax": 0.00,
    "taxAmount": 5287.17,
    "effectiveTaxRate": 24.02
  },
  "salesTax": {
    "revenueSalesTax": 0.00,
    "expenseSalesTax": 0.00,
    "netSalesTax": 0.00
  },
  "quarterlyEstimates": {
    "q1": {
      "dueDate": "2022-03-15 00:00:00.000",
      "federalTax": {
        "taxOwed": 1425.26,
        "taxPaid": 0.00,
        "paymentsAllocatedFromPast": 0.00,
        "paymentsRolledOverToFuture": false,
        "paymentsBalance": 1425.26
      },
      "stateTax": {
        "taxOwed": 1321.79,
        "taxPaid": 0.00,
        "paymentsAllocatedFromPast": 0.00,
        "paymentsRolledOverToFuture": false,
        "paymentsBalance": 1321.79
      }
    },
    "q2": {
      "dueDate": "2022-06-15 00:00:00.000",
      "federalTax": {
        "taxOwed": 950.36,
        "taxPaid": 0.00,
        "paymentsAllocatedFromPast": 0.00,
        "paymentsRolledOverToFuture": false,
        "paymentsBalance": 950.36
      },
      "stateTax": {
        "taxOwed": 881.37,
        "taxPaid": 0.00,
        "paymentsAllocatedFromPast": 0.00,
        "paymentsRolledOverToFuture": false,
        "paymentsBalance": 881.37
      }
    },
    "q3": {
      "dueDate": "2022-09-15 00:00:00.000",
      "federalTax": {
        "taxOwed": 1425.26,
        "taxPaid": 0.00,
        "paymentsAllocatedFromPast": 0.00,
        "paymentsRolledOverToFuture": false,
        "paymentsBalance": 1425.26
      },
      "stateTax": {
        "taxOwed": 1321.79,
        "taxPaid": 0.00,
        "paymentsAllocatedFromPast": 0.00,
        "paymentsRolledOverToFuture": false,
        "paymentsBalance": 1321.79
      }
    },
    "q4": {
      "dueDate": "2022-12-15 00:00:00.000",
      "federalTax": {
        "taxOwed": 1900.17,
        "taxPaid": 0.00,
        "paymentsAllocatedFromPast": 0.00,
        "paymentsRolledOverToFuture": false,
        "paymentsBalance": 1900.17
      },
      "stateTax": {
        "taxOwed": 1762.22,
        "taxPaid": 0.00,
        "paymentsAllocatedFromPast": 0.00,
        "paymentsRolledOverToFuture": false,
        "paymentsBalance": 1762.22
      }
    }
  }
}
```

<Tip>
  The art of building great FinTech apps includes figuring out how to display complex financial data in a way that a given user base can easily digest it. Tight has iterated its tax UX through its own apps, with over 30 versions displayed to 700k+ users. Our team is willing and excited to share our proven UX learnings with you, fast forwarding you through your iteration process and ensuring that your first tax UX is a solid one. Reach out to our API team at [api@hurdlr.com](mailto:api@hurdlr.com), and our team will advise you on which attributes to display and how to do so clearly/concisely.
</Tip>

### Tax reporting

The [T2125](/api-reference/reports/t2125) is generally the most complex portion of any Canadian self-employed individual's tax filing, but Tight makes generating this form a breeze. A T2125 has to be filed for *each* sole proprietorship (line of business) that the user has participated in. Take a look at our [Canada Tax Reporting docs](/v5.0/products/taxes/tax-reporting/t2125-canada) to learn how to easily generate this tax report for each of your users' businesses.

### Accounting

[Tight's "Invisible" Double-Entry Accounting](/guides/business-owners/general-ledger) is enabled in the background, tracking the proper accrual basis transactions in each user's General Ledger. It's up to you whether you want to display this to your users.

Notably, for Canadian users, the [Chart of Accounts](/embeddable-ui/react/accounting/chart-of-accounts) includes an asset account for "Sales Tax Credit" as well as a liability account for "Sales Tax Payable". These accounts are used to store the sales tax paid on expenses as well as the sales tax owed on income, respectively. Tracking these values allows Tight's tax estimates to include the [input tax credits](https://www.canada.ca/en/revenue-agency/services/tax/businesses/topics/gst-hst-businesses/complete-file-input-tax-credit.html) that the CRA extends to businesses.

And, if you use the `autoSalesTax` flag when setting up the user's [tax profile](/guides/business-owners/multi-currency/canadian-accounting#tax-estimates), that tracking will occur automatically.


# EU Support
Source: https://docs.tight.com/guides/business-owners/multi-currency/european-union-accounting

Full native support for LatAm nuances

<Warning>
  This page is under construction. Please check back later for more content.
</Warning>


# LatAm Support
Source: https://docs.tight.com/guides/business-owners/multi-currency/latin-america-accounting

Full native support for LatAm nuances

<Warning>
  This page is under construction. Please check back later for more content.
</Warning>


# UK Support
Source: https://docs.tight.com/guides/business-owners/multi-currency/uk-accounting

Full native support for UK nuances

<Warning>
  This page is under construction. Please check back later for more content.
</Warning>


# Payroll
Source: https://docs.tight.com/guides/business-owners/payroll

Add Payroll and Accounting to turn your platform into a one-stop shop

## Overview

Accounting for companies running payroll, including businesses of one, can be tricky. Tight's [native payroll
integrations](/integrations/payroll/) make this process easy, with zero user input required.

<Tip>Tight supports Accrual Basis, Cash Basis, and Modified Cash Basis accounting methods. Many cash basis businesses
choose to use Modified Cash Basis when enabling payroll for the first time.</Tip>

## Use cases

### Integrating your users existing payroll system

Many of your users already run payroll through established providers. With Tight's native integrations, they can connect
their existing payroll accounts to your platform and immediately benefit from automatic accounting without switching
providers or changing their payroll workflow.

Your users connect their existing payroll providers via one of Tight's native integrations (e.g.,
[Gusto](/integrations/payroll/gusto) retail). Once connected, payroll runs are automatically synced to Tight as
they occur, accounting transactions are created in real-time in the user's General Ledger, and bank withdrawals are
automatically reconciled when they clear. Your users continue running payroll exactly as they do today, and Tight
handles all the accounting complexity in the background.

### Automatic payroll/withdrawal reconciliation

Regardless of which approach you choose, connecting existing payroll systems, embedding payroll into your platform, or
feeding payroll data directly to the Tight API, the automatic reconciliation works the same way. Tight creates the proper
accounting entries for each payroll run and automatically reconciles bank withdrawals when they clear, with zero user
input required.

That reconciliation process, when done manually, can be very complex, as a single payroll run typically includes at
least three bank withdrawals, all of which need to be mapped to different accounts. With the Tight API, this
reconciliation happens automatically, without user input.

#### Monthly Payroll Run Example

Here's a concrete example of what Tight automates:

1. The owner of an S-Corp has two employees and a contractor. They run their monthly payroll:
   * Owner salary: \$6,000
   * Two employees: \$4,000 each (\$8,000 total)
   * One contractor: \$1,000
   * Company payroll taxes: \$2,000 per W-2 worker (\$6,000 total for owner + 2 employees)
   * Employee payroll tax withholding: \$1,000 per W-2 worker (\$3,000 total)
   * Health insurance: \$400 per person (\$1,200 total for owner + 2 employees)
   * Company 401k contributions: \$200 per person (\$600 total for owner + 2 employees)
   * Employee 401k contributions: \$300 per person (\$900 total for owner + 2 employees)
2. The payroll provider processes four separate bank withdrawals:
   * \$12,000 for Employee Net Pay (\$15,000 gross wages minus \$3,000 in tax withholdings)
   * \$9,000 for Payroll Taxes (\$6,000 company portion + \$3,000 withheld from employees)
   * \$1,200 to CareFirst for health insurance
   * \$1,500 to Guideline for 401k (\$600 company contributions + \$900 employee contributions)
3. The Tight API automatically matches these 4 bank withdrawals with the payroll run and performs the following
   accounting splits:
   * **\$12,000 net salary withdrawal** → Split into \$5,000 owner net pay, \$6,000 staff net pay, and \$1,000
     contractor payments
   * **\$9,000 payroll tax withdrawal** → Split into \$6,000 for company payroll taxes (expense), \$1,000 added back to
     owner gross wages, and \$2,000 added back to staff gross wages (since these amounts were withheld from their
     paychecks)
   * **\$1,200 health insurance withdrawal** → Split into \$400 for owner benefits (expense) and \$800 for employee
     benefits (expense)
   * **\$1,500 retirement withdrawal** → Split into \$600 for company 401k contributions (expense) and \$900 for
     employee 401k contributions (treated as additional wages from the company's accounting perspective)
4. Furthermore, the Tight Embedded experience nests these transaction line items neatly under the payroll run, giving
   the business owner complete visibility into their payroll costs without manual reconciliation work.

<Tip>Tight follows best practices with its default payroll accounting; however, you can customize
your [platform's custom Chart of Accounts (CoA)](/guides/get-started/accounting-migrations/default-chart-of-accounts) to
configure the above splits with however much (or little) granularity as your users desire to see in their Financial
Statements.</Tip>

### Embedding payroll into your platform

If you don't already, you can offer payroll directly within your platform with Embedded Payroll. Tight integrates
seamlessly with these providers. Your users can run payroll entirely within your product experience, and
Tight automatically handles all the accounting behind the scenes.

Tight supports three embedded payroll providers:

* [Check](/integrations/payroll/check)
* [Gusto Embedded](/integrations/payroll/gusto#gusto-embedded-payroll)
* [Salsa](/integrations/payroll/salsa)

Once you integrate with an embedded payroll provider and configure it with Tight, your users run payroll directly in
your platform, and Tight receives payroll data in real-time, automatically creates accounting entries, and reconciles
bank withdrawals when they clear. This approach gives you complete control over the payroll UX while Tight handles the
complex accounting automatically, and your users get a seamless, unified experience all within your product.

<Tip>If you haven't embedded payroll yet, an [expert from the Tight team](https://www.tight.com/#get-started) can
introduce you to embedded payroll providers and help you evaluate the best option for your platform.</Tip>


# Taxes
Source: https://docs.tight.com/guides/business-owners/taxes

Provide tax estimates for the business owner of the passthrough entity

## Overview

Tight's Tax Calculations makes it easy for you to provide your users with income tax estimates, with support for many
different income streams, expenses, and tax profiles. The Tight Income Tax API has been proven and reached maturity via
very rigorous maintenance and update processes in place since the 2017 tax year, as well as painstaking quality
assurance processes with a 1% threshold between 3 different sources. The Tight Tax Calculations API currently supports
the United States (50 states + DC) and Canada (all provinces, including GST/HST/PST/QST), but is architected for rapid
expansion into other countries as needed.

## Use cases

The Tight API automatically keeps a General Ledger behind the scenes for all of your users. While your users may never
want to look at a GL or Chart of Accounts, the beauty of the behind-the-scenes GL is that they get all the tax reporting
that they could ever need, without the burden of having to manage a General Ledger or understand bookkeeping.

As the user's business (and financial complexity) grows, the necessary reporting will always be available for them in
real time. For example, if your user is a sole proprietor that normally files a Schedule C, then they decide to become
an LLC necessitating a Form 1065, you will only need to alter one parameter via the Tight API to get them the new tax
report that they need.

### Annual/quarterly tax estimates

Embed the [Income Tax Dashboard](/embeddable-ui/react/income-tax-dashboard) to provide your users with comprehensive tax
estimation functionality directly within your platform. The dashboard gives business owners real-time visibility into
their quarterly and annual tax obligations, including federal and state income taxes, self-employment taxes (if applicable), and
estimated quarterly payments.

#### Multiple income streams

Tight Tax Estimates makes it easy for you to provide your users with income tax estimates, based on their many different incomes streams, including:

* Self-employed (1099) income, with separate P\&Ls and Schedule Cs for each stream
* Business (K-1) income, from pass-through entities like LLCs, LLPs, and S Corporations
* Investment income, including short-term capital gains, long-term capital gains, qualified dividends, etc.
* Ordinary W-2 income

Business owners can view quarterly estimates, understand their effective tax rates, and plan for tax payments without leaving your platform.

#### Tax profile

Your users can set up their tax profile, and Tight automatically calculates their tax obligations in real-time as transactions flow through their accounts. Tight can handle very complex tax profiles, including granularity into:

* Filing Status
* State (or Province)
* Business income (from a passthrough entity)
* W2 income
* Tip income
* Overtime income
* Itemized personal expenses
* Federal & State withholding
* Wage expenses
* Investment and other income types
* Federal Dependents (and other dependents including special circumstances for children older than 17)
* State Dependents (and other dependents including special circumstances for children older than 17)
* Alternative Minimum Tax (AMT) adjustments
* Spousal data

<Tip>To decrease your user's time-to-value, initial user onboarding features a very simple tax profile form (filing status, entity type, etc.)</Tip>

### Tax form generation

Business owners can generate pre-filled tax forms directly from
the [Income Tax Dashboard](/embeddable-ui/react/income-tax-dashboard), or you can generate them programmatically via the
Tight API.

**Via Embedded UI:**
When you embed the [Income Tax Dashboard](/embeddable-ui/react/income-tax-dashboard), your users can generate tax forms
specific to their entity with ease. The dashboard provides complete tax forms as PDFs for filing or record-keeping and
Tax Details report for hand-off to a tax preparer or accountant.

**Via API:**
For programmatic generation, use the Tight API to generate tax forms on demand:

* [Schedule C](/api-reference/reports/schedule-c) - Sole proprietorships
* [Form 1065](/api-reference/reports/form-1065) - Partnerships and multi-member LLCs
* [Form 1120-S](/api-reference/reports/form-1120-s) - S-Corporations
* [Form 1120](/api-reference/reports/form-1120) - C-Corporations
* [T2125](/api-reference/reports/t2125) - Canadian businesses

### Tax professional hand-off

The vast majority of business owners, especially those with formed entities (e.g. LLCs), opt to have their taxes done
for them by a human. Tight makes the business owner's interaction with their tax preparer very quick, as
Tight's [Income Tax Dashboard](/embeddable-ui/react/income-tax-dashboard) allows the user to generate a Tax Details (for
tax filing) report that tax preparers love, allowing seamless import into the tax professional software that tax
preparers typically use behind the scenes. The business owner can simply enter their tax preparer's email address and
have the Tax Details report sent directly to the tax preparer.
<Tip>Tight's Tax Details (for tax filing) report format has been honed for many years, such that tax preparers *love*
the report. They often thank the business owner for the level of organization.</Tip>

### DIY filing

Some business owners, especially self-employed individuals who don't necessarily view themselves as a business, prefer
a low-cost DIY tax filing option. For users who want to file their own taxes, Tight integrates with white-labeled DIY tax
filing platforms like [April](/integrations/tax/april), seamlessly transferring their financial data from Tight directly
into the tax filing platform, where their tax return is pre-filled with all necessary information from the Tight General
Ledger. Once the data is transferred, business owners can review their pre-filled return, make any necessary
adjustments (e.g. for items not tracked in their accounting system, like their personal mortgage), and file
electronically.


# Chart of Accounts
Source: https://docs.tight.com/guides/get-started/accounting-migrations/default-chart-of-accounts

Create and iterate the default Chart of Accounts for each of your platform's key user segments

1. Tight delivers a pre‑configured Chart of Accounts (CoA) template tailored to your user base.
2. Your team can then review and make direct edits to the template.
3. You can also create multiple CoA templates for different business segments.
4. Once revised, Tight accounting experts will review the template(s) and provide best practice feedback to ensure the template allows the businesses on your platform to smoothly migrate off of their legacy accounting platform.
5. Tight [applies the CoA template to your platform account](/api-reference/templates/save-chart-of-accounts-template) so that it will be applied to any new companies you create in the Tight API.

<Tip>Business owners and/or their accountants can modify a given business's Chart of Accounts at any time. The default template(s) are meant to be a highly-tailored starting point for each of the business segments your platform supports.</Tip>


# Introduction
Source: https://docs.tight.com/guides/get-started/introduction-to-tight-accounting-api

Welcome to Tight AI-native Embedded Accounting

## Quickstart

<CardGroup>
  <Card title="Launch without development" icon="rocket-launch" href="/guides/launch-paths/ready-to-launch">
    Validate market demand with Tight Ready-to-Launch Accounting
  </Card>

  <Card title="Embed End-to-End Accounting" icon="table-layout" href="/guides/launch-paths/embed-in-your-ux">
    Embed accounting with Tight's proven white-labeled experience
  </Card>

  <Card title="Build with AI (MCP)" icon="sparkles" href="/guides/launch-paths/build-with-ai">
    Leverage AI to quickly embed accounting into your platform
  </Card>

  <Card title="Explore the Playground" icon="umbrella-beach" href="/playground">
    Explore the Tight Embedded End-to-End UX in the Playground
  </Card>
</CardGroup>

## Agentic Accounting

Tight's AI-native General Ledger (AGL) is now able to automate categorization, reconciliation, anomaly detection, reporting,
and analysis by leveraging LLM-based [Agentic Accountants](/ai/agentic/agentic-accountant).

Having served 1.3M businesses to date, Tight [AI-native Embedded Accounting](/ai/philosophy/ai-native-general-ledger) allows
platforms like yours to provide businesses with the power of real-time financials and reconciliation as well as the
accuracy and reliability of a fully deterministic ledger.

## Use cases

### Augment Your Platform

If you already have invoicing, expense tracking, or bill pay built into your product, Tight's accounting engine can back
your existing features with proper double-entry bookkeeping. Push your existing transaction data to the Tight API, and
Tight automatically maintains the general ledger, enabling financial reporting and reconciliation capabilities you'd
otherwise need to build from scratch.

This approach lets you add complementary features selectively; see below for some example features you can add to your
platform with Tight:

1. [Expense Tracking](/guides/business-owners/bank-transactions#expense-tracking)
2. [Automatic Mileage Tracking](/guides/business-owners/mileage-tracking#automatic-mileage-tracking)
3. [Financial Statements](/guides/business-owners/financial-statements)
4. [Invoicing](/guides/business-owners/invoicing#adding-invoicing-to-your-platform)
5. [Bill Pay](/guides/business-owners/bills#adding-bills-into-your-platform)

### Turnkey Accounting Solution

The [Tight Dashboard](/embeddable-ui/react/financial-overview) provides a complete accounting platform
embedded directly in your product. Your users see a simplified, action-oriented view that surfaces only what requires
their attention — uncategorized transactions, unpaid invoices, upcoming tax deadlines — without overwhelming them with
accounting complexity.

Everything is included: bank connections, expense categorization, invoicing, financial statements, income tax estimates,
and reconciliation. Your users get professional-grade accounting functionality without needing to understand debits,
credits, or journal entries.

### Advanced Accounting Controls

For bookkeepers and sophisticated business owners who need deeper control, embed individual accounting pages alongside
the dashboard. These users can access the [Chart of Accounts](/embeddable-ui/react/accounting/chart-of-accounts) to
customize account structures, the [General Ledger](/embeddable-ui/react/accounting/general-ledger) to review
transaction-level detail, and the [Journal](/embeddable-ui/react/accounting/journal) to create manual journal entries
for depreciation, amortization, or complex adjustments. This gives power users the granular control they expect while
keeping the experience simple for everyone else.

## What Tight enables

### Financial Reporting

The double-entry General Ledger that Tight maintains automatically enables
comprehensive [financial reporting](/guides/business-owners/financial-statements) without requiring your users to
understand accounting mechanics. Every transaction that flows through your platform, whether it's an invoice,
bank transaction, bill, or payroll run, automatically updates the appropriate GL accounts in real-time.

This means your users get instant access
to [Profit & Loss statements](/guides/business-owners/financial-statements#profit-&-loss-income-statement), [Balance Sheets](/guides/business-owners/financial-statements#balance-sheet), [Cash Flow Statements](/guides/business-owners/financial-statements#cash-flow-statement),
and [Trial Balance reports](/guides/business-owners/financial-statements) without manual
bookkeeping work.

Bookkeepers and accountants working within your platform can drill down from any report line item directly into the
underlying transactions and journal entries, providing the audit trail and transparency needed for professional
accounting work.

### Automated reconciliation

Tight's accounting engine automatically handles the complex reconciliation scenarios that typically require manual
bookkeeping intervention. When a payment processor (
e.g. [Adyen](/integrations/payment-processing/adyen), [Stripe](/integrations/payment-processing/stripe)) payout hits a
business's bank account, Tight automatically matches it to the underlying invoices, merchant fees, and payment
processing charges without any manual matching required. See how this works in practice
with [automatic payment/payout reconciliation](/guides/business-owners/invoicing#automatic-paymentpayout-reconciliation).

The same automation applies
to [matching bill payments](/guides/business-owners/bills#adding-automatic-bill/withdrawal-reconciliation-to-your-existing-bill-pay),
bank transfers between
accounts, [payroll withdrawals](/guides/business-owners/payroll#automatic-payrollwithdrawal-reconciliation), and other
multi-leg transactions that traditionally create reconciliation headaches. Your users see clean, reconciled books
without needing to understand the accounting mechanics happening in the background.

### Dimensions

Many businesses need to track profitability across multiple dimensions beyond just account categories, e.g. by location,
product line, project, or department. Tight's [dimensions](/guides/business-owners/dimensions) functionality
enables this multi-dimensional reporting without requiring your users to maintain complex account structures.

Your platform can define the dimensions and hierarchies made available to the business on your platform, and the
businesses can define the values against those dimensions. Your users can assign dimensions to transactions, invoices, and
expenses, then generate Profit & Loss reports segmented by dimension to understand which locations, products, or projects
are most profitable. This is particularly valuable for platforms serving multi-location businesses, project-based
services, or any vertical where profitability analysis by segment drives business decisions.

The dimension tracking integrates seamlessly with Tight's accounting engine, so businesses get accurate profitability
reporting by segment while maintaining a clean, simple Chart of Accounts structure.


# AI-based Support
Source: https://docs.tight.com/guides/get-started/launch-checklist/ai-support

Leverage Tight's comprehensive knowledge base to train your support agents

## Overview

AI chat support helps your team accurately and efficiently answer complex customer questions around your embedded
accounting product, without requiring your support team to have accounting expertise.

Tight has seen \~80% of inquiries can be covered by AI chat when trained properly, and importantly, Tight will customize
its proven content to match your platform's implementation *and* train your AI agent such that it covers the majority of
inquiries.

In addition to AI-based support, Tight's Customer Success team will schedule training sessions with your support staff
to enable them to support advanced accounting use cases.

## Knowledge Base

Tight customizes its comprehensive knowledge base, honed with and proven across 1.3 million businesses, with screenshots
and content specific to your platform, and then uploads the Markdown content directly into your AI agent's
knowledge base. Markdown ensures compatibility with AI support agents as well as easy formatting and readability.

This content includes detailed user guides, troubleshooting steps, and answers to common customer questions.
<Tip>Tight's Customer Success team can train your Intercom Fin or Zendesk AI Agent for you</Tip>

## MCP Tools for user-specific AI support

If you have an in-house chat support agent that is able to leverage MCP Tools (
e.g., [Fin by Intercom](https://www.intercom.com/help/en/articles/11461635-add-mcp-connectors-for-popular-apps-or-custom-mcps)),
then Tight's [MCP Server](/ai/mcp-tools/end-user-support-mcp) can be integrated so that your support agent has direct
access to the specific user's data, allowing personalized support.

## Support Staff Training

Tight's Customer Success team schedules training sessions with your support staff to get them up to speed on supporting
accounting use cases.

Your support staff's leadership will have direct access to Tight's Customer Success team, allowing your team to maintain
its brand voice while having the comfort of direct access to experts in the Tight Embeddable UI.

<Tip>When using [Tight human-assisted done-for-you (DFY) books](/guides/solutions/dfy), Tight's Bookkeeping team
provides support directly to your users via the Tight Bookkeeping Dashboard.</Tip>


# Launch
Source: https://docs.tight.com/guides/get-started/launch-checklist/launch

Launch your new platform

Once Tight Embedded Accounting up and running in your product, you're ready to launch with your users. Tight's Customer
Success team provides the following services immediately prior to every customer-partner's launch:

## AI Support (and Staff) Training

[Tight's Customer Success trains your AI and your team.](/guides/get-started/launch-checklist/ai-support)

## Quality Assurance

For your benefit, Tight's QA team tests your sandbox implementation prior to your go-live date. Once you provide Tight
with credentials to your sandbox or staging environment, Tight's experienced QA team will verify your implementation of
the Tight API as well as provide UX feedback.

## Production Access to Tight

Once the QA process is complete, you should:

1. Request Production keys to the Tight API
2. Update the Tight API URL from `https://sandbox.tight.com` to `https://prod.tight.com`

## Production Access to Integrations

An important part of launching your product is getting production environment access to
the [various native integrations](/integrations/native-integrations) (
e.g., [Plaid](/integrations/banking/plaid), [Unit](/integrations/banking/unit), [Stripe](/integrations/payment-processing/stripe))
that your product utilizes. Given the sensitive nature of the data being processed, these providers often require
security questionnaires prior to granting production access. The Tight API team, which is SOC 2 Type 2 compliant, is
experienced with these approval processes and will be ready to support you through this process.

## Email Branding

To ensure your new accounting product's emails match with the rest of your brand's design language, Tight offers the
ability
for [report and invoicing emails to go out from your domain](/guides/get-started/launch-checklist/email-branding#domain-smtp-configuration)
and with [customizable design templates](/guides/get-started/launch-checklist/email-branding#email-design-customization)
that align with your brand.


# User Activation
Source: https://docs.tight.com/guides/get-started/launch-checklist/user-activation

Track and maximize user activation funnels

Immediately after [launching embedded accounting](/guides/get-started/launch-checklist/launch), your product team will
want to track key user activation funnels and optimize against those funnels. If you'd like to set user activation on
auto-drive, you can enable [Tight's Twilio integration](/integrations/customer-service/twilio), which use smart SMS
messages to handle all onboarding and activation lifecycle messaging.

## Activating through timely notifications

With detailed user-level events, Tight gives you the tools to send the right notification at the right time, ensuring
you are helping your users activate as successfully as possible.

### Defining the channel

#### SMS

While many of Tight's customer-partners already have already established notification channels with their userbase (e.g.
SMS, push notifications, in-app chat, email), customer-partners often find less friction by simply allowing [Tight's
Agentic Accountant to text the business owner](/integrations/customer-service/twilio) the same way a human would
whenever a quick action is needed.

#### Push Notifications

If you already send out push notifications, you can simply subscribe
to [Tight's lifecycle webhooks](/api-reference/webhooks#lifecycle-webhooks), and then use those webhooks to trigger push
notifications to your users. Additionally, if you utilize Intercom for in-app chat and/or push notifications, you can
leverage [Tight's Intercom integration](/integrations/customer-service/intercom).

#### Email

If you already send out emails, you can simply subscribe
to [Tight's lifecycle webhooks](/api-reference/webhooks#lifecycle-webhooks), and then use those webhooks to trigger
emails. Alternatively, [Tight can send out lifecycle emails on your behalf](/guides/get-started/launch-checklist/email-branding).

### Triggering the right notifications

The following events are proven to drive initial user activation:

#### Linking banks or credit cards

Event: `bankLinked`

Notification timing: User registered >2 days ago and `bankLinked` not triggered

Messaging: Link your card to automate your expense tracking

Follow-up actions: `transactionCreated`, `transactionEdited`, `transactionRuleSuggested`

#### Setting up invoicing

Event: `invoiceSetupCompleted`

Notification timing: User registered >5 days ago and `invoiceSetupCompleted` not triggered

Messaging: Customize your invoices and get paid faster

Follow-up actions: `invoicePaymentProcessingSetupCompleted`, `invoiceDrafted`, `invoiceSent`

## Tracking user activation funnels

### Defining key user activation funnels

There are many different ways to define funnels depending on the goals of your product. Two of the most common examples
are described below:

#### Expense Tracking Funnel

| Funnel Step | Event | Description |
| :- | :- | :- |
| 1 | `companyCreated` | User registered |
| 2 | `bankLinked` | User linked their bank or credit card for automated transaction categorization |
| 3 | `transactionsProcessed` | Transactions have been processed from an integration such as Plaid, Unit, or CSV Import |
| 4 | `transactionRuleSuggested` | Tight system suggests a rule for automatic expense categorization to the user |
| 5 | `transactionRuleAccepted` | User accepted an automated expense rule, indicating that they have customized/personalized the app to their needs. User is then rewarded and retained by automatic expense categorization. |

#### Invoicing Funnel

| Funnel Step | Event | Description |
| :- | :- | :- |
| 1 | `companyCreated` | User registered |
| 2 | `invoiceSetupCompleted` | User added their company branding, logo, address, etc., to customize their invoice template |
| 3 | `invoicePaymentProcessingSetupCompleted` | User is now able to accept credit card and ACH payments |
| 4 | `invoiceSent` | User sent an invoice to their client |
| 5 | `invoicePaid` | User received payment from their client for an invoice (and is very likely retained) |

<Tip>Tight's GTM team is glad to help you define the activation funnels that are most critical to your product.</Tip>

### Tracking user-driven events

In order to receive the important user-driven events for tracking and optimizing user activation, you will want to
subscribe to events via one or more of the following methods:

a. [Intercom integration](/integrations/customer-service/intercom): if your team utilizes Intercom for user support and
messaging

b. [Mixpanel integration](/integrations/analytics/mixpanel): if your team utilizes Mixpanel for tracking aggregate user
behavior

c. [Lifecycle webhooks](/api-reference/webhooks#lifecycle-webhooks): if your team has custom-built user messaging and
behavior tracking flows

d. [Data Lakes](/guides/business-owners/data-lakes#integrations): if your team has custom-built flows and wants to get
user behavior data into your data scientists' hands without involving developers


# Custom authentication
Source: https://docs.tight.com/guides/get-started/user-provisioning/use-custom-authentication

Create Tight accounts with a few lines of code

If your platform rolls its own authentication mechanism, utilize the Tight API to provision user accounts and retrieve access tokens.

## Create a company

When a business opts into your new Bookkeeping product, [create their company in Tight](/api-reference/company-management/create-a-company).

The creation of the company accepts a `userId` for the business owner from your system, so there is no need to store any Tight identifiers in your platform.

## Get an access token

Using the `userId` used to create the user's company along with your client credentials, make a simple request to retrieve an access token:

```bash theme={null}
curl -X POST https://sandbox.tight.com/v6/auth/token \
-u client_id:client_secret \
-d userId=your_userId
```

The Tight API will respond with your granted access token:

```json theme={null}
{
    "access_token": "<access_token>",
    "token_type": "Bearer",
    "expires_in": 3600
}
```

This token can be used to [embed Tight UI](/embeddable-ui/react/patterns/embedding) or to directly [hit the Tight API](/api-reference/authentication#using-the-access-token).


# Identity provider
Source: https://docs.tight.com/guides/get-started/user-provisioning/use-existing-identity-provider

Configure SSO for embedded accounting with zero developer effort

If your platform uses a popular identity provider, like Auth0, AWS Cognito, Okta, or Stytch, then you can authenticate
your users to Tight Embedded Accounting by following the steps below (no developer required).

## Securely sharing your JWKS path

Simply use
the [Configure Identity Provider API](/api-reference/identity-provider-configuration/configure-identity-provider) to
specify your Identity Provider and Issuer URI.

## Configure business-specific attributes

Tight will use the standard user claims (attributes) included by your identity provider, like `email`, `name`, etc.

Additionally, you can set up the following optional company-specific attributes in your identity provider:

| Claim | Description |
| - | - |
| `companyName` | Name of the user's company |
| `entityType` | The type of the entity (SOLE\_PROPRIETORSHIP, LLP, LLC, S\_CORP, C\_CORP) |
| `companyId` | Id of the company in your DB |
| `address` | Address of the company |

## Get a JWT access token

### Ready-to-Launch

If you are using Ready-to-Launch accounting, then you simply need
to [route your user to the Ready-to-Launch app](/guides/launch-paths/ready-to-launch#route-your-user-to-the-ready-to-launch-app).
The RTL app will take care of the authenication using your identity provider.

### Embedding Tight

If you are embedding accounting into your existing UX, then you can obtain a JWT from your identity provider, and
simply [pass that JWT into the front-end components as the access token](/guides/launch-paths/embed-in-your-ux#front-end-development-1-day).


# Custom Integrations
Source: https://docs.tight.com/guides/integrations/custom-integrations

Allow Tight to ingest granular data already stored in your platform

If you're interested in Tight Custom Integrations, please see [Tight Custom Integrations](/integrations/custom-integrations).


# Native Integrations
Source: https://docs.tight.com/guides/integrations/native-integrations

Leverage the Tight API’s wide range of seamless integrations

If you're interested in Tight Native Integrations, please see [Tight Native Integrations](/integrations/native-integrations).


# Build with AI (MCP)
Source: https://docs.tight.com/guides/launch-paths/build-with-ai

Leverage AI to quickly embed accounting

Whether you're tight on development resources or have a dedicated software development team, Tight allows you to embed end-to-end accounting in no time by leveraging the latest in AI technology.

Your product leader(s) may already be familiar with the Model Context Protocol (MCP), but even if they aren't, Tight is a great first use case for modern AI tooling in your organization.

<Tip>New to AI or interested in learning best practices? Tight's AI-native engineering team (which makes up 80% of the Tight team as a whole) is ready and excited to walk you through the AI tooling it uses in-house.</Tip>

You can use large language models (LLMs) to embed Tight. Tight provides tooling and best practice guidance for using LLMs.

## Tight Model Context Protocol (MCP) Server

The Tight Model Context Protocol (MCP) server provides tools that AI agents can use to embed end-to-end accounting utilizing Tight's documentation.

See the [Model Context Protocol documentation](/ai/mcp-tools/embedding-and-integration-mcp) to connect your AI Agents or IDE of choice to the Tight MCP server.

Once connected, AI agents will automatically leverage Tight's documentation to quickly add accounting functionality to your product. See below for an example with Claude Code.

## Example: Adding Accounting to Existing Product

**Prompt:** "Add a navigation item called "Accounting" that routes to Tight's Financial Overview"

**AI (Claude) response:**

> ⏺ Perfect! I've successfully added an "Accounting" navigation item that routes to Tight's Financial Overview. Here's what I implemented:<br /><br />
>
> Changes Made:
>
> 1. Created TightFinancialOverview\.jsx - A new component that embeds Tight's Financial Overview, providing:
>    1. Monthly financial summaries
>    2. Onboarding action items (linking bank accounts, etc.)
>    3. Transaction review notifications
>    4. Access to financial reporting (P\&L, Balance Sheet, etc.)
> 2. Updated App.jsx (App.jsx:3, App.jsx:13, App.jsx:77-90):
>    1. Updated navigation bar to add "Accounting" that routes to TightFinancialOverview\.jsx
>
> How It Works:
>
> 1. The "Accounting" button navigates to the Financial Overview, utilizing the Tight `access_token` in state.


# Embed in your UX (5 days)
Source: https://docs.tight.com/guides/launch-paths/embed-in-your-ux

Integrate accounting features natively into your existing product

This launch path outlines the typical path to launching embedded accounting in your existing product.

This approach is best for organizations that prioritize accounting on their product roadmap. This implementation path scales for platforms supporting hundreds of thousands of businesses.

If your platform is more interested in proving accounting demand with less than 1000 businesses, your product team will likely instead prefer [Tight Ready-to-Launch Accounting](/guides/launch-paths/ready-to-launch).

## Configure your SSO/authentication mechanism (1 day)

1. Use your existing identity provider (e.g. Auth0, AWS Cognito, Okta, or Stytch) by following Tight's [user provisioning with existing identity provider](/guides/get-started/user-provisioning/use-existing-identity-provider) instructions.
2. Or, use custom code to [provision Tight user accounts using the Tight API](/guides/get-started/user-provisioning/use-custom-authentication).

## Design (2 days)

1. Decide where to place the "Bookkeeping" navigation item inside your UX
2. [Preview and customize the branding/styling](/embeddable-ui/react/patterns/design) on the Business Owner Dashboard
3. Receive your tailored theme from Tight for front-end developer use (see below)

## Front-end Development (1 day)

1. Add "Bookkeeping" navigation item to your existing product
2. When your user clicks the "Bookkeeping" navigation item, [get an access token](/api-reference/authentication) and [render the embedded end-to-end UX](/embeddable-ui/react/patterns/embedding)

## Configure additional data integrations (post-launch)

Tight has many data integrations, including [native integrations](/integrations/native-integrations) with popular financial platforms (e.g. Plaid, Stripe, Adyen) as well as [custom integrations](/integrations/custom-integrations) to ingest granular data already stored in your platform (e.g. invoices and line items stored in a Vertical SaaS platform, dimension hierarchies like cost centers, regions, locations, departments, etc.). The Tight team will create a custom implementation plan for your specific platform to ensure any financial data stored in your platform flows into your new accounting product. For example, the invoices tracked in your system are automatically reconciled with the bank deposits flowing into Tight.


# Ready-to-Launch (24h)
Source: https://docs.tight.com/guides/launch-paths/ready-to-launch

Launch Bookkeeping in 24 hours with zero developer effort

Follow the two simple administrative steps below to authenticate your users and launch full-featured accounting on your domain (e.g. accounting.mySaaSplatform.com).

This approach is best for fast-moving organizations that want to get to market quickly (up to 1000 businesses) and start collecting GTM/acquisition data to further build the case for an embedded accounting roadmap.

Typically, after your GTM team gets 1000+ businesses on Tight Ready-to-Launch Accounting, your product team will likely opt to augment your core product by [fully embedding accounting user experiences](/guides/launch-paths/embed-in-your-ux) into it.

## Configure your SSO/authentication mechanism

### Use your existing identity provider (zero developer effort)

<Tip>If you use Auth0, AWS Cognito, Okta, or Stytch, this is the authentication mechanism you should use.</Tip>
You can configure your existing identity provider's JWKS path, by following Tight's [user provisioning with existing identity provider](/guides/get-started/user-provisioning/use-existing-identity-provider) instructions.

### Or, provision users with custom code (one developer day)

If you're not using an existing identity provider of if you simply prefer a custom integration, you can [provision Tight user accounts using the Tight API](/guides/get-started/user-provisioning/use-custom-authentication).

## Route your user to the Ready-to-Launch app

If you are using an existing identity provider, contact the Tight team for the URL that you should redirect your user to.

If you are using custom code to authenticate your user with the [create company endpoint](/api-reference/company-management/create-a-company), the response on this endpoint contains the `readyToLaunchUrl` that you can simply redirect your user to.

## Configure your custom domain

By default, the Ready-to-Launch website URL is hosted on tight.com (e.g. `https://mySaaSplatform.prod.rtl.tight.com`). If you would like to change it to your own custom domain (e.g. `https://bookkeeping.mySaaSplatform.com`), you can do so by following the steps below:

1. Specify your Custom Bookkeeping domain (e.g. [https://bookkeeping.mySaaSplatform.com](https://bookkeeping.mySaaSplatform.com))
2. Specify your existing login page URL (e.g. [https://app.mySaaSplatform.com/login](https://app.mySaaSplatform.com/login))
3. Create CNAME Record on your DNS provider
   1. Go to your DNS provider’s website (e.g. [GoDaddy](https://ie.godaddy.com/help/add-a-cname-record-19236) or [Cloudflare](https://www.cloudflare.com/dns/)).
   2. Go to the "DNS" section
   3. Add a CNAME record for your Bookkeeping custom domain:
      1. Give the CNAME a "Name" value based on the first part of your custom domain, e.g. if your custom domain is `bookkeeping.mySaaSplatform.com`, use `bookkeeping`.
      2. Give the CNAME a "Data" value based on Tight's default RTL URL for your platform (e.g. `mySaaSplatform.prod.rtl.tight.com`)
   4. Add a CNAME record for your new bookkeeping SSL certificate:
      1. Give the CNAME a "Name" value provided to you by your Tight CSM
      2. Give the CNAME a "Data" value provided to you by your Tight CSM


# Human-assisted DFY Books
Source: https://docs.tight.com/guides/solutions/dfy

Quickly launch done-for-you bookkeeping by following this step-by-step plan

This implementation plan outlines the typical path to launching human-assisted bookkeeping in your product. Each section
is titled after the role/job function that would typically complete the underlying steps:

## Planning/administrative (1 day)

1. [Curate your default Chart of Accounts template](/guides/get-started/accounting-migrations/default-chart-of-accounts)
2. [Configure your bank linkage integration](/integrations/banking/plaid)
3. [Configure your automated email domain](/guides/get-started/white-labeled-experience/email-domain)

## Design (1 day)

1. Decide where to place the "Bookkeeping" navigation item inside your UX
2. [Preview and customize the](/embeddable-ui/react/patterns/design) Business Owner Dashboard
3. Receive your tailored theme from Tight for front-end developer use (see below)

## Development (2 days total)

### Back-end (1 day)

1. When a business opts into your new Bookkeeping
   product, [create their company in Tight](/api-reference/company-management/create-a-company)
2. If you are using Tight's Ready-to-Launch product, the API response contains the `readyToLaunchUrl` that you can
   simply return to your front-end and redirect your user to
3. If you're not using Ready-to-Launch, create an endpoint
   to [get a short-lived UI access token](/api-reference/authentication) (no need to store in DB)
   <Tip>If you use Auth0, AWS Cognito, Okta, or Stytch, you can skip the above back-end development steps
   by [using your existing identity provider](/guides/get-started/user-provisioning/use-existing-identity-provider).</Tip>

### Front-end (1 day)

1. Add "Bookkeeping" navigation item to your existing product
2. When your user clicks the "Bookkeeping" navigation item:
   1. Get an access token from your back-end (see above)
   2. Redirect your user to the Ready-to-Launch page
   3. Or, [Embed](/embeddable-ui/react/patterns/embedding)
      the [Financial Overview](/embeddable-ui/react/financial-overview) using the access token and theme
      <Tip>This dashboard presents the owner-operator with only the info that they need to see, such as transactions
      the bookkeeper needs input on. <br /><br />It additionally includes a sub-navigation menu for power users to access
      granular functionality, such as the full transactions dashboard, mileage tracking, income taxes, etc. <br /><br />
      If your product already has a well-defined navigation structure, you can disable the sub-navigation inside the
      Business Owner Dashboard and utilize your own navigation.</Tip>

## GTM

1. Roll out your Bookkeeping Product in a phased approach
   1. 10 users: work directly with users to onboard them and get feedback
   2. 100 users: test automated onboarding flows (e.g. UI-based onboarding call scheduling), Tight-led CoA iteration
      based on transactional data, and build confidence in bookkeeping operations
   3. 1000 users: Vertical-specific learnings/efficiencies generated for Tight algorithms and bookkeepers
2. [Provide top-tier Support](/guides/get-started/launch-checklist/ai-support)
3. Productization/pricing strategy

[//]: # "## Post-launch Future Roadmap"

[//]: #

[//]: # "1. Invoicing integration"

[//]: # "2. [Payment Processing integration](/integrations/payment-processing/stripe)"

[//]: # "3. [Payroll integration](/integrations/payroll/gusto)"


# AI-assisted DIY Books
Source: https://docs.tight.com/guides/solutions/diy

Launch a full accounting software solution for your business owners to manage their books with AI assistance

This implementation plan outlines the typical path to launching AI-assisted accounting in your product. Each section is
titled after the role/job function that would typically complete the underlying steps:

## Planning/administrative (1 day)

1. [Curate your default Chart of Accounts template](/guides/get-started/accounting-migrations/default-chart-of-accounts)
2. [Configure your bank linkage integration](/integrations/banking/plaid)
3. [Configure your automated email domain](/guides/get-started/white-labeled-experience/email-domain)

## Design (1 day)

1. Decide where to place the "Accounting" navigation item inside your UX
2. [Preview and customize the Business Owner Dashboard](/embeddable-ui/react/patterns/design)
3. Receive your tailored theme from Tight for front-end developer use (see below)

## Development (2 days total)

### Back-end (1 day)

1. When a business opts into your new Bookkeeping
   product, [create their company in Tight](/api-reference/company-management/create-a-company)
2. If you are using Tight's Ready-to-Launch product, the API response contains the `readyToLaunchUrl` that you can
   simply return to your front-end and redirect your user to
3. If you're not using Ready-to-Launch, create an endpoint
   to [get a short-lived UI access token](/api-reference/authentication) (no need to store in DB)
   <Tip>If you use Auth0, AWS Cognito, Okta, or Stytch, you can skip the above back-end development steps
   by [using your existing identity provider](/guides/get-started/user-provisioning/use-existing-identity-provider).</Tip>

### Front-end (1 day)

1. Add "Accounting" navigation item to your existing product
2. When your user clicks the "Bookkeeping" navigation item:
   1. Get an access token from your back-end (see above)
   2. Redirect your user to the Ready-to-Launch page
   3. Or, [Embed](/embeddable-ui/react/patterns/embedding)
      the [Financial Overview](/embeddable-ui/react/financial-overview) using the access token and theme
      <Tip>This dashboard presents the owner-operator with only the info that they need to see, such as transactions
      requiring review, easy access to financial reports, etc. <br /><br />It additionally includes a sub-navigation menu
      for power users to access granular functionality, such as the full transactions dashboard, mileage tracking,
      income taxes, etc. <br /><br />If your product already has a well-defined navigation structure, you can disable the
      sub-navigation inside the Business Owner Dashboard and utilize your own navigation.</Tip>

## GTM

1. Roll out your Accounting Product in a phased approach
   1. 10 users: work directly with users to onboard them and get feedback
   2. 100 users: test automated onboarding flows (e.g. UI-based onboarding call scheduling), Tight-led CoA iteration
      based on transactional data, build confidence in accounting operations
   3. 1000 users: Vertical-specific learnings/efficiencies generated for Tight algorithms and bookkeepers
2. [Provide top-tier Support](/guides/get-started/launch-checklist/ai-support)
3. Productization/pricing strategy

[//]: # "## Post-launch Future Roadmap"

[//]: #

[//]: # "1. Invoicing integration"

[//]: # "2. [Payment Processing integration](/integrations/payment-processing/stripe)"

[//]: # "3. [Payroll integration](/integrations/payroll/gusto)"


# Audit Trail
Source: https://docs.tight.com/api-reference/audit-trail

Audit changes to entities in the Tight API

## Overview

The Tight API stores every modification to every entity along with details about each revision, e.g. the date and time, the editor, and the source of the change.

An individual entity can be audited to see all revisions to that entity or the entry audit trail can be retrieved to view a chronological log of every action and the entities affected.

## Audit an entity

All top-level entities in the Tight API support pulling their Audit Trail. This can be fetched via a URL of the form `/v6/auditTrail/{id}`.

For example to audit a bank transaction, use the following request:

```bash theme={null}
curl -X GET 'https://sandbox.tight.com/v6/auditTrail/btn_936723' \
-H 'Authorization: Bearer <access_token>'
```

This will return a list of revisions for the specified bank transaction:

```json theme={null}
{
    "result": "SUCCESS",
    "data": [{
        "company": {
          "id": "fake_companyId"
        },
        "editor": {
          "userId": "fake_userId",
          "email": "user@tight.com"
        },
        "action": "Transactions edited by user@tight.com",
        "datetime": "2025-06-17T14:24:32.926Z",
        "revision": {
            "id": "btn_936723",
            "category": {
              "id": "cat_354231"
            }
        }
    }],
    "error": []
}
```

<Tip>
  For large audit trails, utilize pagination to retrieve all changes. See the [pagination documentation](/api-reference/pagination) for more information.
</Tip>

## Review the full Audit Trail

The Tight API supports pulling the full audit trail for any company, providing all changes to all entities belonging to that company in a chronological order:

```bash theme={null}
curl -X POST 'https://sandbox.tight.com/v6/auditTrail/query' \
-H 'Authorization: Bearer <access_token>'
```

This will return all audit trail entries:

```json theme={null}
{
    "result": "SUCCESS",
    "data": [{
        "company": {
          "id": "fake_companyId"
        },
        "editor": {
          "userId": "fake_userId",
          "email": "user@tight.com"
        },
        "action": "Transactions edited by user@tight.com",
        "datetime": "2025-06-17T14:24:32.926Z",
        "revisions": [{
            "id": "btn_936723",
            "category": {
              "id": "cat_354231"
            }
        },
        {
            "id": "btn_936724",
            "category": {
              "id": "cat_354231"
            }
        }]
    }],
    "error": []
}
```

<Note>
  The entries returned in the above audit trail are determined by the `access_token` used. See the [Authentication docs](/api-reference/authentication#authentication-scenarios) for more info.
</Note>

## Editors

When modifications are made to an entity in the Tight API, the `access_token` used to make those edits determines the `editor` on the associated audit trail entry.

If a `userId` was used to generate the `access_token`, edits made using that access token will reflect that user on the audit trail. If a `userId` was not used, i.e. Partner-level authentication is being used to access the Tight API, the audit trail will reflect your platform's name as the editor on the audit trail.

## Audit a specific editor

The full Audit Trail can be filtered to a specific editor to audit changes made by a specific user, e.g. a bookkeeper
across all companies:

```bash theme={null}
curl -X POST https://sandbox.tight.com/v6/auditTrail/query \
-H 'Authorization: Bearer <access_token>' \
-D '{
      "filter": {
        "editor": {
          "userId": {
            "equal": "fake_bookkeeper_userId"
          }
        }
      }
    }'
```

This will return all Audit Trail entries caused by Bookkeeper `fake_bookkeeper_userId`.


# Audit an entity
Source: https://docs.tight.com/api-reference/audit-trail/audit-an-entity

https://dev.tight.com/v3/api-docs get /v6/auditTrail/{entityId}
Retrieve the Audit Trail for an entity in the Tight API



# Query audit trail
Source: https://docs.tight.com/api-reference/audit-trail/query-audit-trail

https://dev.tight.com/v3/api-docs post /v6/auditTrail/query
Query audit trail entries for the authenticated user



# Generate one-time link
Source: https://docs.tight.com/api-reference/auth/generate-one-time-link

https://dev.tight.com/v3/api-docs post /v6/auth/oneTimeLink
Generate a one-time authentication link. The link's shape depends on the caller's token type: a partner-level token must provide userId; an accountant-level token may optionally provide companyId to generate a link that acts as that company's owner; a business-owner token generates a link for its own company.



# Authentication
Source: https://docs.tight.com/api-reference/authentication

Obtain and use bearer tokens with the Tight API

## Get Started

The Tight API uses access tokens to authenticate requests. To get started, simply exchange your client credentials and a `userId` for an access token:

```bash theme={null}
curl -X POST https://sandbox.tight.com/v6/auth/token \
-u client_id:client_secret \
-d userId=your_userId
```

The Tight API will respond with your granted access token:

```json theme={null}
{
    "access_token": "<access_token>",
    "token_type": "Bearer",
    "expires_in": 3600
}
```

This token can be used anywhere in the Tight API to access this user's data.

## Partner-level Authentication

The `userId` in the above request is optional. You can omit it to request a token that can access data across *all* of your users:

```bash theme={null}
curl -X POST https://sandbox.tight.com/v6/auth/token \
-u client_id:client_secret
```

See the [POST /token reference](/api-reference/oauth/token) for more information.

## Bookkeeper Authentication

Passing the `userId` of a bookkeeper returns a token that can access every company that bookkeeper is permitted to work on. To scope a bookkeeper's token to a single company, add the `apiCompanyId` parameter alongside the bookkeeper's `userId`:

```bash theme={null}
curl -X POST https://sandbox.tight.com/v6/auth/token \
-u client_id:client_secret \
-d userId=bookkeeper_userId \
-d apiCompanyId=company_userId
```

The resulting token acts as that bookkeeper working on behalf of the specified company, so requests return only that company's data and changes are audited to the bookkeeper. This is the recommended approach when a bookkeeper on your platform performs operations for one company at a time, rather than reusing a partner-level token.

<Note>`apiCompanyId` requires `userId` to be the ID of a bookkeeper who can access the given company.</Note>

## Token Scopes

You can pass an optional `scope` field when requesting a token from `POST /v6/auth/token` to limit what the token can do:

* `read` gives read-only access
* `write` gives read and write access
* If omitted, `scope` defaults to `write`

For example, to request a read-only token:

```bash theme={null}
curl -X POST https://sandbox.tight.com/v6/auth/token \
-u client_id:client_secret \
-d userId=your_userId \
-d scope=read
```

## Using the Access Token

Include the returned token in the `Authorization` header of any request to the Tight API:

```bash theme={null}
curl --location --request POST 'https://sandbox.tight.com/v6/banks/transactions' \
-H 'Authorization: Bearer <access_token>'
```

The above request retrieves bank transactions available to the provided `access_token`.

## Authentication Scenarios

How the token was generated impacts what data the above request will return. For example, when using a token generated for a specific business owner (via their `userId`), the request will return bank transactions belonging to that user's company.

The following table outlines what data is accessible based on the `userId` provided:

| Authentication Type | Data Accessible |
| - | - |
| Business owner | Only that company |
| Bookkeeper | All companies the bookkeeper can access |
| Bookkeeper scoped to a company | Only that company |
| None (Partner-level) | All companies |

<Note>How the token was generated impacts how the Tight API audits changes to entities modified using that token. See the [Audit Trail docs](/api-reference/audit-trail#editors) for more info.</Note>

## Token Renewal

Instead of tracking token expiration, generate a new token for each user session.
<Check>Tight Embedded Components automatically refresh tokens for you.</Check>


# Delete bank account
Source: https://docs.tight.com/api-reference/bank-accounts/delete-bank-account

https://dev.tight.com/v3/api-docs delete /v6/banks/accounts/{id}
Delete a bank account for the given id



# Get bank account
Source: https://docs.tight.com/api-reference/bank-accounts/get-bank-account

https://dev.tight.com/v3/api-docs get /v6/banks/accounts/{id}
Get a bank account for the given id



# Query bank accounts
Source: https://docs.tight.com/api-reference/bank-accounts/query-bank-accounts

https://dev.tight.com/v3/api-docs post /v6/banks/accounts/query
Query bank accounts for the authenticated user



# Save bank accounts
Source: https://docs.tight.com/api-reference/bank-accounts/save-bank-accounts

https://dev.tight.com/v3/api-docs post /v6/banks/accounts
Save new (or update existing) bank accounts



# Delete bank reconciliation
Source: https://docs.tight.com/api-reference/bank-reconciliations/delete-bank-reconciliation

https://dev.tight.com/v3/api-docs delete /v6/banks/reconciliations/{id}
Delete a bank reconciliation for the given id



# Get bank reconciliation
Source: https://docs.tight.com/api-reference/bank-reconciliations/get-bank-reconciliation

https://dev.tight.com/v3/api-docs get /v6/banks/reconciliations/{id}
Get a bank reconciliation for the given id



# Query reconciliations
Source: https://docs.tight.com/api-reference/bank-reconciliations/query-reconciliations

https://dev.tight.com/v3/api-docs post /v6/banks/reconciliations/query
Query reconciliations for the authenticated user



# Save reconciliations
Source: https://docs.tight.com/api-reference/bank-reconciliations/save-reconciliations

https://dev.tight.com/v3/api-docs post /v6/banks/reconciliations
Save new (or update existing) reconciliations



# Delete bank statement
Source: https://docs.tight.com/api-reference/bank-statements/delete-bank-statement

https://dev.tight.com/v3/api-docs delete /v6/banks/statements/{id}
Delete a bank statement for the given id



# Get bank statement
Source: https://docs.tight.com/api-reference/bank-statements/get-bank-statement

https://dev.tight.com/v3/api-docs get /v6/banks/statements/{id}
Get a bank statement for the given id



# Query bank statements
Source: https://docs.tight.com/api-reference/bank-statements/query-bank-statements

https://dev.tight.com/v3/api-docs post /v6/banks/statements/query
Query bank statements for the authenticated user



# Save bank statements
Source: https://docs.tight.com/api-reference/bank-statements/save-bank-statements

https://dev.tight.com/v3/api-docs post /v6/banks/statements
Save new (or update existing) bank statements



# Delete bookkeeper
Source: https://docs.tight.com/api-reference/bookkeepers/delete-bookkeeper

https://dev.tight.com/v3/api-docs delete /v6/bookkeepers/{id}
Delete an bookkeeper for the given id



# Get bookkeeper
Source: https://docs.tight.com/api-reference/bookkeepers/get-bookkeeper

https://dev.tight.com/v3/api-docs get /v6/bookkeepers/{id}
Get an bookkeeper for the given id



# Invite bookkeeper
Source: https://docs.tight.com/api-reference/bookkeepers/invite-bookkeeper

https://dev.tight.com/v3/api-docs post /v6/bookkeepers/invite
Send an email invitation to an accountant for the authenticated user



# Query bookkeepers
Source: https://docs.tight.com/api-reference/bookkeepers/query-bookkeepers

https://dev.tight.com/v3/api-docs post /v6/bookkeepers/query
Query bookkeepers for the authenticated user



# Save bookkeepers
Source: https://docs.tight.com/api-reference/bookkeepers/save-bookkeepers

https://dev.tight.com/v3/api-docs post /v6/bookkeepers
Save new (or update existing) bookkeepers



# Get closing
Source: https://docs.tight.com/api-reference/closing/get-closing

https://dev.tight.com/v3/api-docs get /v6/closing
Get the authenticated user's closing configuration



# Save closing
Source: https://docs.tight.com/api-reference/closing/save-closing

https://dev.tight.com/v3/api-docs post /v6/closing
Save the authenticated user's closing configuration



# Create a company
Source: https://docs.tight.com/api-reference/company-management/create-a-company

https://dev.tight.com/v3/api-docs post /v6/company
Create a company in the Tight API



# Delete company
Source: https://docs.tight.com/api-reference/company-management/delete-company

https://dev.tight.com/v3/api-docs delete /v6/company/{id}
Delete a company for the given id



# Get a company
Source: https://docs.tight.com/api-reference/company-management/get-a-company

https://dev.tight.com/v3/api-docs get /v6/company/{id}
Get a company in the Tight API for the given id



# Query companies
Source: https://docs.tight.com/api-reference/company-management/query-companies

https://dev.tight.com/v3/api-docs post /v6/company/query
Query companies for the authenticated user



# Get conversation
Source: https://docs.tight.com/api-reference/conversations/get-conversation

https://dev.tight.com/v3/api-docs get /v6/conversations/{id}
Get a conversation for the given id



# Get conversation messages
Source: https://docs.tight.com/api-reference/conversations/get-conversation-messages

https://dev.tight.com/v3/api-docs get /v6/conversations/{id}/messages
Get messages for the given conversation



# Query conversations
Source: https://docs.tight.com/api-reference/conversations/query-conversations

https://dev.tight.com/v3/api-docs post /v6/conversations/query
Query conversations for the authenticated user



# Save conversations
Source: https://docs.tight.com/api-reference/conversations/save-conversations

https://dev.tight.com/v3/api-docs post /v6/conversations
Save a new (or update an existing) set of conversations



# Custom Data
Source: https://docs.tight.com/api-reference/custom-data

Augment Tight API entities with freeform custom data

## Get Started

All Tight API entities have a `customData` parameter. Use this parameter to attach freeform JSON data to Tight API entities.

Custom data can be used to add additional, structured information on an entity. For example, you can add an internal identifier to a Bank Transaction or specialized tax info on a user's General Ledger accounts:

```bash theme={null}
curl -X POST https://sandbox.tight.com/v6/banks/transactions \
-H 'Authorization: Bearer <access_token>' \
-D '[{
        "id": "btn_936723",
        "customData": {
            "internal_key": "some_internal_key",
            "some_other_field": 23434
        }
    }]'
```

<Info>
  `customData` can support up to 50 fields and up to 2000 characters of freeform JSON data
</Info>

Once added, this bank transaction's `customData` will be included anywhere else the transaction can be fetched from the Tight API. For example, the response to the following request includes the `customData` set on this bank transaction:

```bash theme={null}
curl -X GET 'https://sandbox.tight.com/v6/banks/transactions/btn_936723' \
-H 'Authorization: Bearer <access_token>'
```

```json theme={null}
{
    "result": "SUCCESS",
    "data": {
        "id": "btn_936723",
        "type": "REVENUE",
        "amount": 15399,
        "customData": {
            "internal_key": "some_internal_key",
            "some_other_field": 23434
        }
        /* remainder of the properties on this bank transaction */
    },
    "error": []
}
```

<Check>
  The `customData` object now appears in the response, you can leverage this functionality to enhance integrations, reporting, or internal workflows.
</Check>

## Update custom data

When you update an entity, `customData` is **merged per key** into the existing value, rather than replacing
it. Each top-level key in the request is handled on its own:

| Key in the request | Result |
| - | - |
| Omitted | The existing value for that key is kept |
| Present with a value | The value is set, replacing any existing value for that key |
| Present with `null` | The key is removed |

To clear all custom data on the entity, send `"customData": null`. Omitting `customData` from the request leaves
it unchanged.

The merge is one level deep. Arrays and nested objects are treated as a single value and are **replaced whole**,
never merged into.

<Warning>
  You can't store a literal `null` as a value, because `null` means "delete this key". If you need to represent an
  empty value, use a different sentinel, such as an empty string or `false`.
</Warning>

### Examples

Each example below starts from the existing `customData` shown under **Before**, then sends the `customData` shown
under **Request** in an update, such as this bank transaction update:

```bash theme={null}
curl -X POST https://sandbox.tight.com/v6/banks/transactions \
-H 'Authorization: Bearer <access_token>' \
-D '[{
        "id": "btn_936723",
        "customData": { "some_other_field": 50000 }
    }]'
```

<Tabs>
  <Tab title="Add a key">
    ```json Before theme={null}
    { "internal_key": "some_internal_key" }
    ```

    ```json Request theme={null}
    { "region": "northeast" }
    ```

    ```json After theme={null}
    { "internal_key": "some_internal_key", "region": "northeast" }
    ```
  </Tab>

  <Tab title="Overwrite a key">
    ```json Before theme={null}
    { "internal_key": "some_internal_key", "some_other_field": 23434 }
    ```

    ```json Request theme={null}
    { "some_other_field": 50000 }
    ```

    ```json After theme={null}
    { "internal_key": "some_internal_key", "some_other_field": 50000 }
    ```
  </Tab>

  <Tab title="Delete a key">
    ```json Before theme={null}
    { "internal_key": "some_internal_key", "some_other_field": 23434 }
    ```

    ```json Request theme={null}
    { "some_other_field": null }
    ```

    ```json After theme={null}
    { "internal_key": "some_internal_key" }
    ```
  </Tab>

  <Tab title="Replace a nested object">
    ```json Before theme={null}
    { "internal_key": "some_internal_key", "prefs": { "email": true, "sms": false } }
    ```

    ```json Request theme={null}
    { "prefs": { "sms": true } }
    ```

    ```json After theme={null}
    { "internal_key": "some_internal_key", "prefs": { "sms": true } }
    ```

    The whole `prefs` object is replaced, so `email` is dropped. To keep it, send the full object:
    `{ "prefs": { "email": true, "sms": true } }`. Arrays behave the same way.
  </Tab>

  <Tab title="Clear all">
    ```json Before theme={null}
    { "internal_key": "some_internal_key", "some_other_field": 23434 }
    ```

    ```json Request theme={null}
    null
    ```

    Send `"customData": null` in the request body, rather than an object.

    ```json After theme={null}
    null
    ```
  </Tab>
</Tabs>

## Filter on custom data

Coming soon


# Delete customer
Source: https://docs.tight.com/api-reference/customers/delete-customer

https://dev.tight.com/v3/api-docs delete /v6/customers/{id}
Delete a customer for the given id



# Get customer
Source: https://docs.tight.com/api-reference/customers/get-customer

https://dev.tight.com/v3/api-docs get /v6/customers/{id}
Get a customer for the given id



# Query customers
Source: https://docs.tight.com/api-reference/customers/query-customers

https://dev.tight.com/v3/api-docs post /v6/customers/query
Query customers for the authenticated user



# Save customers
Source: https://docs.tight.com/api-reference/customers/save-customers

https://dev.tight.com/v3/api-docs post /v6/customers
Save new (or update existing) customers



# Delete dimension value
Source: https://docs.tight.com/api-reference/dimensions/delete-dimension-value

https://dev.tight.com/v3/api-docs delete /v6/dimensions/values/{id}
Delete a dimension value. Cannot delete dimension values with children or associated bank transactions.



# Query dimension values
Source: https://docs.tight.com/api-reference/dimensions/query-dimension-values

https://dev.tight.com/v3/api-docs post /v6/dimensions/values/query
These contain the dimension values that your user tracks against. For example, if you defined a dimension of "Location", your user could define their dimension values as "NA Branch", "Asia Branch", "EU Branch".



# Save dimension values
Source: https://docs.tight.com/api-reference/dimensions/save-dimension-values

https://dev.tight.com/v3/api-docs post /v6/dimensions/values
Save a new (or update an existing) set of dimension values



# Delete employee
Source: https://docs.tight.com/api-reference/employee-management/delete-employee

https://dev.tight.com/v3/api-docs delete /v6/employees/{id}
Delete an employee for the given id



# Get employee
Source: https://docs.tight.com/api-reference/employee-management/get-employee

https://dev.tight.com/v3/api-docs get /v6/employees/{id}
Get an employee for the given id



# Query employees
Source: https://docs.tight.com/api-reference/employee-management/query-employees

https://dev.tight.com/v3/api-docs post /v6/employees/query
Query employees for the authenticated partner, optionally filtered to a single company



# Save employees
Source: https://docs.tight.com/api-reference/employee-management/save-employees

https://dev.tight.com/v3/api-docs post /v6/employees
Save new (or update existing) employees



# Errors
Source: https://docs.tight.com/api-reference/errors

Handle errors in the Tight API

## Overview

The Tight API employs conventional HTTP response codes to indicate the success or failure of an API request. See the table below for a summary of status codes the Tight API uses:

### HTTP Status Codes

| | | |
| - | - | - |
| 200 | OK | Everything worked as expected. |
| 207 | Multi-status | Partial success, some aspects of the request failed. |
| 400 | Bad Request | The request was unacceptable, often due to validation error. |
| 401 | Unauthorized | The `access_token` provided is invalid. |
| 403 | Forbidden | The `access_token` doesn't have permissions to perform the request. |
| 404 | Not Found | The requested resource doesn't exist. |
| 409 | Conflict | The request hit constraints due to concurrent requests. Please try again. |
| 429 | Too Many Requests | The rate limit was hit, see [Rate Limits](/api-reference/rate-limiting) for more details. |
| 500, 503, 504 | Server Errors | Something went wrong on Tight's end. (These are rare.) |

## Error Responses

In addition to the HTTP response codes, the Tight API has a unified `error` schema on all error responses.

<ParamField type="enum<string>">
  The type of the error. Safe for programmatic use.

  Available options: `UNKNOWN_ERROR`, `EXPIRED_TOKEN`, `INVALID_TOKEN`, `BAD_REQUEST`, `JSON_ERROR`, `DUPLICATE`, `REQUIRED`, `INVALID_VALUE`, `NOT_MODIFIABLE`, `INVALID_FORMAT`, `CONFLICT`
</ParamField>

<ParamField type="string">
  A human-readable message providing more details about the error.
</ParamField>

<ParamField type="string">
  If the error is parameter-specific, the parameter related to the error. This can be used to display a message near the correct form field.
</ParamField>

## Validations

All operations in the Tight API include an array of `error` objects so that the API consumer receives all possible errors with a given request.

For example, if attempting to save a bank transaction without its amount and with an invalid bank account, the following error response would be returned:

```json theme={null}
{
    "result": "FAILURE",
    "data": null,
    "error": [
        {
            "type": "REQUIRED",
            "message": "Amount is required",
            "param": "amount"
        },
        {
            "type": "INVALID_VALUE",
            "message": "The bank account provided is not valid",
            "param": "bankAccountId"
        }
    ]
}
```

<Tip>
  The Tight API is designed to provide user-facing error messages and field-level validation out of the box. As an additional best practice, log and monitor errors for troubleshooting and analytics.
</Tip>

## Retrying and Escalating

For server errors (`500`, `503`, `504`), retry the request with exponential backoff. If errors persist, escalate to the Tight API team. For rate limiting errors (`429`), see the [Rate Limits documentation](/api-reference/rate-limiting) for guidance on handling retries and backoff.


# Query GL accounts
Source: https://docs.tight.com/api-reference/gl-accounts/query-gl-accounts

https://dev.tight.com/v3/api-docs post /v6/accounting/glAccounts/query
Query GL accounts for the authenticated user



# Delete reaction
Source: https://docs.tight.com/api-reference/messages/delete-reaction

https://dev.tight.com/v3/api-docs delete /v6/messages/{id}/reactions/{emojiCode}
Delete a reaction from the given message



# Get message
Source: https://docs.tight.com/api-reference/messages/get-message

https://dev.tight.com/v3/api-docs get /v6/messages/{id}
Get message for the given id



# Save messages
Source: https://docs.tight.com/api-reference/messages/save-messages

https://dev.tight.com/v3/api-docs post /v6/messages
Save a new set of messages



# Save reaction
Source: https://docs.tight.com/api-reference/messages/save-reaction

https://dev.tight.com/v3/api-docs post /v6/messages/{id}/reactions/{emojiCode}
Save a new reaction to the given message.



# Introspect Access Token
Source: https://docs.tight.com/api-reference/oauth/introspect

openapi-oauth.yaml POST /v6/auth/introspect
Inspect an access token to verify its validity and retrieve its metadata



# Revoke Access Token
Source: https://docs.tight.com/api-reference/oauth/revoke

openapi-oauth.yaml POST /v6/auth/revoke
Revoke an access token or refresh token, rendering it immediately invalid



# Request Access Token
Source: https://docs.tight.com/api-reference/oauth/token

openapi-oauth.yaml POST /v6/auth/token
Exchange client credentials for a bearer access token



# Pagination
Source: https://docs.tight.com/api-reference/pagination

Page efficiently through Tight API resources

## Get Started

All top-level Tight API resources support pulling data in bulk by utilizing cursor-based pagination.

To get started, simply specify the `limit`, which is the number of items to return on that page:

```bash theme={null}
curl -X POST https://sandbox.tight.com/v6/banks/transactions/query \
-H 'Authorization: Bearer <access_token>' \
-D '{
        "limit": 100
    }'
```

The response will contain an array of items up to your specified `limit` in `data` and a `cursor` object:

```json theme={null}
{
    "result": "SUCCESS",
    "data": [/* list of bank transactions */],
    "error": [],
    "cursor": {
        "after": "eyJBRlRFUiI6ImJ0bl8xNjkifQ==",
        "before": "eyJCRUZPUkUiOiJidG5fMTg2MTAifQ=="
    }
}
```

## Paginate Forward or Backward

Use the `cursor.after` value to fetch the next page, or `cursor.before` to fetch the previous page. Include the appropriate cursor value in your next request.

```bash theme={null}
curl -X POST https://sandbox.tight.com/v6/banks/transactions/query \
-H 'Authorization: Bearer <access_token>' \
-D '{
        "limit": 100,
        "cursor": "eyJCRUZPUkUiOiJidG5fMTg2MTAifQ=="
    }'
```

<Check>
  If the response contains `cursor.after: null`, you have reached the last page. If `cursor.before: null`, you are on the first page.
</Check>

## Sort and Jump to a Specific Page

To sort results, add a `sorts` parameter. To jump to a specific spot, use the `start` property within `sorts`.

```bash theme={null}
curl -X POST https://sandbox.tight.com/v6/banks/transactions/query \
-H 'Authorization: Bearer <access_token>' \
-D '{
        "limit": 100,
        "sort": [{
            "orderBy": "description",
            "direction": "ASC",
            "start": "B"
        }],
    }'
```

<Tip>
  Cursor-based pagination is ideal for building user experiences where users can page forward, page backward, sort, and jump to specific pages from any page.
</Tip>


# Rate Limits
Source: https://docs.tight.com/api-reference/rate-limiting

Learn about API rate limits and how to work with them

## Overview

The Tight API uses a number of safeguards against bursts of incoming traffic to help maximize its stability. If you send many requests in quick succession, you might see error responses with status code `429`.

<Warning>
  If you consistently exceed rate limits, your access may be temporarily blocked or degraded. Always monitor your usage and handle rate limiting gracefully to avoid service interruptions.
</Warning>

The limit is **1000 requests over a five minute window**, scoped to a Tight API `access_token`.

## Handling limits gracefully

A basic technique for integrations to gracefully handle limiting is to watch for `429` status codes and build in a retry mechanism. The retry mechanism should follow an exponential backoff schedule to reduce request volume when necessary.

Here is an example of exponential backoff in JavaScript:

```javascript theme={null}
async function fetchWithBackoff(url, options, maxRetries = 5) {
  let retries = 0;
  let delay = 1000; // Start with 1 second
  while (retries < maxRetries) {
    const response = await fetch(url, options);
    if (response.status !== 429) {
      return response;
    }
    await new Promise(res => setTimeout(res, delay));
    delay *= 2; // Exponential backoff
    retries++;
  }
  throw new Error('Max retries exceeded due to rate limiting.');
}
```

<Check>
  If your integration automatically retries with exponential backoff after receiving a 429, you are handling rate limits gracefully.
</Check>

<Tip>
  * Monitor the rate limit headers to proactively adjust your request volume.
  * Log all 429 responses for later analysis and troubleshooting.
  * Design your integration to queue or batch requests when possible to avoid bursts.
</Tip>


# Delete summary
Source: https://docs.tight.com/api-reference/summaries/delete-summary

https://dev.tight.com/v3/api-docs delete /v6/summaries/{id}
Delete a summary for the given id



# Get summary
Source: https://docs.tight.com/api-reference/summaries/get-summary

https://dev.tight.com/v3/api-docs get /v6/summaries/{id}
Get a summary for the given id



# Query summaries
Source: https://docs.tight.com/api-reference/summaries/query-summaries

https://dev.tight.com/v3/api-docs post /v6/summaries/query
Query summaries for the authenticated user



# Save summaries
Source: https://docs.tight.com/api-reference/summaries/save-summaries

https://dev.tight.com/v3/api-docs post /v6/summaries
Save new (or update existing) summaries



# Delete task
Source: https://docs.tight.com/api-reference/tasks/delete-task

https://dev.tight.com/v3/api-docs delete /v6/tasks/{id}
Delete (dismiss) a task for the given id. Only dismissable tasks can be deleted.



# Get task
Source: https://docs.tight.com/api-reference/tasks/get-task

https://dev.tight.com/v3/api-docs get /v6/tasks/{id}
Get a task for the given id



# Query tasks
Source: https://docs.tight.com/api-reference/tasks/query-tasks

https://dev.tight.com/v3/api-docs post /v6/tasks/query
Query tasks for the authenticated user with pagination and filtering support



# Webhooks
Source: https://docs.tight.com/api-reference/webhooks

Subscribe to and handle webhooks from the Tight API

## Get Started

The Tight API uses webhooks to communicate changes to entities and for notable lifecycle events, e.g. an invoice being
paid. To get started, simply reach out to your Tight API contact and provide the following info:

1. Your Tight API `client_id`
2. Webhook URL(s) for the Sandbox environment
3. Webhook URL(s) for the Production environment

Tight sends webhooks from the following IP addresses:

* 3.221.92.254
* 34.200.77.221

## Entity update webhooks

Any time an entity is updated in the Tight API, whether by a user or a third-party integration, the Tight API sends an
`ENTITY_UPDATE` webhook to communicate that change. These webhooks contain a JSON body with the full detail of the
entity that was updated:

```json theme={null}
{
  "editor": {
    "userId": "fake_userId"
  },
  "company": {
    "id": "co_1234",
    "apiCompanyId": "id_1234"
  },
  "type": "ENTITY_UPDATE",
  "url": "/v6/banks/transactions/btn_936723",
  "data": {
    "id:": "btn_936723",
    "type": "REVENUE",
    "amount": 15399
    /* remainder of the bank transaction's properties */
  }
}
```

<Note>
  The entity in the `data` field is at least as up-to-date as the event that triggered the webhook. To get the latest
  version of the entity at any time, use the `url` field.
</Note>

## Lifecycle webhooks

The Tight API's `LIFECYCLE` webhooks provide real-time lifecycle event data, useful for performing analytics, notifying
users of pertinent events, and ultimately optimizing activation & retention. The webhooks contain a JSON body with data
relevant to the event:

```json theme={null}
{
  "editor": {
    "userId": "fake_userId"
  },
  "company": {
    "id": "co_1234"
  },
  "type": "LIFECYCLE",
  "event": "bankAccountCreated",
  "datetime": "2025-04-01T11:31:04.1Z",
  "eventData": {
    "entityId": "fake_id",
    "apiName": "PLAID",
    "type": "DEPOSITORY"
  }
}
```

Refer to the [Lifecycle Event Dictionary](/guides/business-owners/lifecycle-event-dictionary) for the full list of lifecycle events.

<Card title="Additional use cases" icon="thumbs-up">Lifecycle Events can be used in varying ways depending on your
product's use case. For example, if your product manages corporate/employee spend, it may benefit your user experience
to make the `transactionCreated` event trigger a push notification prompting the user to add a receipt image. The
`eventData` included with the `transactionCreated` event contains the information necessary to route the user to the
exact transaction that requires a receipt.</Card>

## Webhook verification

Tight signs every webhook, so that you have the option to verify the webhooks you receive. This helps you protect
against a bad actor flooding your server with fake webhooks.

**Verifying Webhooks**
Tight follows the [JSON Web Token (JWT) standard](https://jwt.io/introduction) and includes its JWTs in the
`Tight-Verification` HTTP header of the webhook.

To verify a Tight JWT, follow these steps:

<Steps>
  <Step>
    Extract the `Tight-Verification` HTTP header from the Tight webhook
  </Step>

  <Step>
    Select [a JWT library](https://jwt.io/libraries) of your choice
  </Step>

  <Step>
    Pass in HMAC-SHA256 as the signing algorithm to your selected JWT library and then use the library to verify the value of the `Tight-Verification` header against your `webhook_secret`

    ```javascript theme={null}
    import 'dotenv/config';
    import express from "express";
    import { jwtVerify } from "jose";

    const app = express();

    // Your webhook_secret
    const webhook_secret = process.env.SECRET;

    app.post("/webhook", express.raw({type: "application/json"}), async (req, res) => {
        const jwt = req.get('Tight-Verification');

        let payload;
        try {
            // Verify the JWT using the HMAC-SHA256 signing algorithm
            const jwtVerifyResult = await jwtVerify(jwt, webhook_secret, {algorithms: ["HS256"]});
            payload = jwtVerifyResult.payload;
        } catch (err) {
            return res.status(400).send(`JWT failed to verify: ${err.message}`);
        }
    });
    ```

    <Note>If your library does not automatically decode the JWT, Base64Url decode the JWT payload and deserialize it into a JSON object.</Note>
  </Step>

  <Step>
    Ensure that the webhook is not expired. Verify that the difference between the `iat` field of the payload and the current `NumericDate` timestamp is within your tolerance. Tight recommends a default tolerance of 5 minutes.

    ```javascript theme={null}
    app.post("/webhook", express.raw({type: "application/json"}), async (req, res) => {
        // Validate the iat, i.e. make sure the webhook has not expired
        // Tight recommends a default tolerance of five minutes
        const TIME_TOLERANCE = (60 * 5);
        let timestamp = payload.iat;
        const now = Math.floor(Date.now() / 1000);
        if (now - timestamp >= TIME_TOLERANCE) {
            return res.status(400).send("Webhook expired")
        }
    });
    ```
  </Step>

  <Step>
    Ensure that the webhook was not modified by anyone other than Tight. Verify that the `request_body_sha256` field of the payload is equal to the SHA-256 hash of the webhook's request body.

    ```javascript theme={null}
    import { timingSafeEqual } from "node:crypto";
    const { subtle } = globalThis.crypto;

    app.post("/webhook", express.raw({type: "application/json"}), async (req, res) => {
        // Validate the webhook body hash
        const enc = new TextEncoder();
        const bodyDigest = await subtle.digest("SHA-256", req.body);
        const webhookHash = enc.encode(btoa(String.fromCharCode(...new Uint8Array(bodyDigest))));
        const claimHash = enc.encode(payload.request_body_sha256 as string);
        if (!timingSafeEqual(webhookHash, claimHash)) {
            return res.status(400).send("Webhook payload modified")
        }


        // Verification succeeded
        // You can process the webhook here or call the next handler in your request-response cycle
        res.send("Webhook verification succeeded");
    });
    ```
  </Step>
</Steps>

<Check>
  If all verification steps succeed, you can be confident the webhook came from Tight and is safe to process.
</Check>


# Complete Business Owner UX
Source: https://docs.tight.com/embeddable-ui/app/business-owners

The entire business owner experience, with a near-zero implementation time

If you're interested in launching embedded accounting in 24 hours with zero developer effort, please see [Tight Ready-to-Launch Accounting](/guides/launch-paths/ready-to-launch).

`<TightApp />` is an all-in-one component that delivers the complete Tight embedded experience: every page, with built-in navigation.
Use it when you want the full experience as a drop-in solution.

<Tip>Looking to embed individual pages instead? See [Embedding](/embeddable-ui/react/patterns/embedding).</Tip>

## Installation

`TightApp` ships in Tight's React Component Library:

<CodeGroup>
  ```bash npm theme={null}
  npm install @tight-embedded/react@latest
  ```

  ```bash pnpm theme={null}
  pnpm add @tight-embedded/react@latest
  ```
</CodeGroup>

## Usage

Unlike individual page components, `TightApp` does not require the `<Tight>` provider. Pass your `accessToken` and target `environment` directly:

```TSX AccountingApp.tsx theme={null}
import { TightApp } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function AccountingApp({ accessToken }) {
    return (
      <TightApp environment="SANDBOX" accessToken={accessToken} />
    )
}
```

You can obtain an applicable `accessToken` via the Tight [Authentication Endpoint](/api-reference/authentication).

<Info>
  The ESLint rule `no-unresolved` might warn that `@tight-embedded/react/index.css` does not exist.

  Disable the lint rule on the import line, or import from `@tight-embedded/react/dist/index.css` directly. Please note that the
  direct path might change in future versions.
</Info>

## Props

<ParamField type="string">
  Bearer token used to authenticate API requests. Get one from the Tight [Authentication Endpoint](/api-reference/authentication).
</ParamField>

<ParamField type="&#x22;PRODUCTION&#x22; | &#x22;SANDBOX&#x22;">
  Selects the Tight API environment. Use `"SANDBOX"` for development and testing.
</ParamField>

<ParamField type="NavState">
  The page that opens on initial render. Defaults to the Financial Overview. An object that contains the `page` field.

  Available options: `FinancialOverview`, `TransactionsDashboard`, `BanksAndIntegrations`, `ExpenseDashboard`, `IncomeDashboard`, `ReportDashboard`, `GeneralLedger`, `ChartOfAccounts`
</ParamField>

## Set the initial page

By default, `TightApp` opens on the Financial Overview. Use `initialNav` to open a different page on first render:

```TSX AccountingApp.tsx theme={null}
import { TightApp } from "@tight-embedded/react";
import "@tight-embedded/react/index.css";

function AccountingApp({ accessToken }) {
    return (
      <TightApp
        environment="SANDBOX"
        accessToken={accessToken}
        initialNav={{ page: "FinancialOverview" }}
      />
    )
}
```


# QuickBooks Online Import
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/imports/quickbooks-online-import

Import accounting data from QuickBooks Online

## Overview

While [independent research shows that 62% of small businesses don't use any accounting software yet](https://www.tight.com/embedded-accounting-smb-vertical-software-report), leaving a major greenfield opportunity for your platform, Tight's customer-partners have also migrated thousands of businesses off of QuickBooks Online using Tight's QBO Import functionality.

The QBO Import functionality allows you to transfer a business’s QBO data into your embedded accounting platform, preserving the business’s historical financial information.

<img alt="QuickBooks Online Import Demo" />

<V5OnlyWarning href="/v5.0/embeddable-ui/imports/quickbooks-online-import-component" />

## Embedding the QuickBooks Online Import

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the QuickBooks Online Import:

```javascript theme={null}
Tight.render(containerId, "ImportQBO");
```


# Wave Import
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/imports/wave-import

Import accounting data from Wave

## Overview

While [independent research shows that 62% of small businesses don't use any accounting software yet](https://www.tight.com/embedded-accounting-smb-vertical-software-report), leaving a major greenfield opportunity for your platform, Tight's customer-partners have also migrated hundreds of businesses off of Wave using Tight's Wave Import functionality.

The Wave Import functionality allows you to transfer a business’s Wave data into your embedded accounting platform, preserving the business’s historical financial information.

<V5OnlyWarning href="/v5.0/embeddable-ui/white-labeled-experience/how-to-embed" />

## Embedding the Wave Import

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the Wave Import:

```javascript theme={null}
Tight.render(containerId, "ImportWave");
```


# Xero Import
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/imports/xero-import

Import accounting data from Xero

## Overview

While [independent research shows that 62% of small businesses don't use any accounting software yet](https://www.tight.com/embedded-accounting-smb-vertical-software-report), leaving a major greenfield opportunity for your platform, Tight's customer-partners have also migrated thousands of businesses off of Xero using Tight's Xero Import functionality.

The Xero Import functionality allows you to transfer a business’s Xero data into your embedded accounting platform, preserving the business’s historical financial information.

<img alt="Xero Import Demo" />

<V5OnlyWarning href="/v5.0/embeddable-ui/imports/xero-import-component" />

## Embedding the Xero Import

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the Xero Import:

```javascript theme={null}
Tight.render(containerId, "ImportXero");
```


# Income Tax Dashboard
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/income-tax-dashboard

Manage and track the business owner's income tax obligations

## Overview

The Income Tax Dashboard is all you need to provide full income tax functionality to the owner of a pass-through entity.
Utilizing the Tight Income Tax API, which has been proven and reached maturity via very rigorous maintenance/update
processes in place since the 2017 tax year, as well as painstaking quality assurance processes with a 1% threshold
between 3 different sources.

The Tight Tax Calculations API currently supports the United States (50 states + DC) and Canada (all provinces,
including GST/HST/PST/QST), but is architected for rapid expansion into other countries as needed.

The Income Tax Dashboard provides a full user experience, allowing your users to:

* Set up their tax profile
* View quarterly income tax estimates
* Generate Form 1040 Schedule C, Form 1065, Form 1120-S, Form 1120, and T2125 tax reports
* Download a full Tax Details report for hand-off to a tax preparer
* Transfer data into a white-labeled DIY tax filing platform, including April and Column Tax

<img alt="Tax Dashboard Demo" />

<V5OnlyWarning href="/v5.0/products/taxes/tax-estimates/embeddable-tax-dashboard" />

## Embedding the Income Tax Dashboard

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions
on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the Income Tax Dashboard:

```javascript theme={null}
Tight.render(containerId, "IncomeTaxDashboard");
```


# Invoice Dashboard
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/invoicing/invoice-dashboard

The fully-featured experience for viewing and managing invoices (A/R)

## Overview

The Invoice Dashboard is all you need to provide full invoicing to your users, with a full user experience allowing your users to:

* Create invoices with auto-complete line items, including:
  * Reimbursement for expenses (including mark-ups)
  * Ability to bill for time tracked
  * Manual line item creation
  * Sales tax line items
* Invoice template customization to match your user's business's branding, including:
  * Custom logo upload
  * Custom brand colors using color wheel or hex code
  * Ability to set business address and sender
* See status of invoices, including when the customer last viewed the invoice
* Generate Aged AR reporting

<V5OnlyWarning href="/v5.0/products/invoicing/embeddable-invoice-dashboard" />

## Embedding the Invoice Dashboard

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the Invoice Dashboard:

```javascript theme={null}
Tight.render(containerId, "InvoiceDashboard");
```


# Mileage Dashboard
Source: https://docs.tight.com/embeddable-ui/plain-js/pages/mileage-dashboard

Track and manage business mileage for tax deductions

## Overview

The Mileage Dashboard is all you need to provide full mileage tracking to your users, with a full user experience allowing your users to:

* Add drives, with auto-complete start and end addresses, route calculation/visualization, and reverse geocoding
* View drives/routes/addresses
* Classify drive purpose (business vs. personal)
* Define favorite locations
* Assign drives to dimensions

<img alt="Mileage Dashboard Demo" />

<V5OnlyWarning href="/v5.0/embeddable-ui/mileage/mileage-dashboard-component" />

## Embedding the Mileage Dashboard

To initialize the Tight Embedded experience using plain Javascript in your project, follow the instructions on [Embedding Tight's white-labeled UI](/embeddable-ui/plain-js/patterns/embedding).

Below is an example JS embedding of the Mileage Dashboard:

```javascript theme={null}
Tight.render(containerId, "MileageDashboard");
```


# Amazon S3
Source: https://docs.tight.com/integrations/analytics/amazon-s3

Push accounting and analytics data directly to your Amazon S3 buckets

## Overview

Tight integrates directly with Amazon S3 to periodically upload raw accounting data to your own S3 buckets. By pushing data into your S3 infrastructure, Tight eliminates the need for your data team to build direct connections to the Tight API, allowing your team to work in the data stack they're already using.

Data is exported in [Parquet file](https://parquet.apache.org/) format on daily, weekly, or monthly intervals, including bank linkage data, invoices, lifecycle events, and transactions. Learn more about available data types and use cases in the [Data Lakes guide](/guides/business-owners/data-lakes).

## Create an Amazon S3 Bucket

If you haven't done so already, create an [AWS account](https://aws.amazon.com/) and [set up an S3 bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) where Tight will upload your data. You can name this bucket anything you'd like; "tight-api-data" is used for the examples shown below.

<img alt="Create S3 Bucket" />

Make note of the AWS Region that you selected, as you'll need to share this with Tight.

## Configure IAM Policy for Programmatic Access

Next, [create an IAM policy](https://aws.amazon.com/blogs/security/writing-iam-policies-how-to-grant-access-to-an-amazon-s3-bucket/) to grant programmatic access to your S3 bucket.

In the AWS IAM Console, navigate to Policies and click "Create policy". Select the JSON option and paste the following policy:

```json theme={null}
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::tight-api-data"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:PutObject",
                "s3:GetObject",
                "s3:DeleteObject"
            ],
            "Resource": [
                "arn:aws:s3:::tight-api-data/*"
            ]
        }
    ]
}
```

<Tip>
  Replace `tight-api-data` with your actual bucket name in both Resource ARNs.
</Tip>

<img alt="IAM Policy JSON" />

Click "Next: Tags" (or "Next: Review" depending on your AWS console version):

<img alt="Policy Next Step" />

On the review step, provide a descriptive name like "tight-api-data-access" and click "Create policy":

<img alt="Policy Review" />

## Create IAM User

[Create an IAM user](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console) that will be used by Tight to access your S3 bucket.

In the AWS IAM Console, navigate to Users and click "Add user". Provide a descriptive username like "tight-api-data-user":

<img alt="Add IAM User" />

On the permissions step, select "Attach existing policies directly" and search for the policy you created (e.g., "tight-api-data-access"):

<img alt="Attach Policy to User" />

Click through the remaining steps:

<img alt="Review User" />

On the final review, click "Create user":

<img alt="Create User" />

After the user is created, you'll see the option to "Download .csv" containing the access credentials. Download this file securely:

<img alt="Download Credentials CSV" />

<Tip>
  For enhanced security, create a dedicated IAM user specifically for Tight with permissions limited only to the target S3 bucket.
</Tip>

## Securely Share Access with Tight

Contact Tight directly at [api@tight.com](mailto:api@tight.com) for instructions on how to securely share:

* The IAM credentials CSV file you downloaded
* Your S3 bucket name
* The AWS region where your bucket is located

Once configured, Tight will automatically begin uploading data files to your S3 bucket based on your preferred schedule (daily, weekly, or monthly). Files are organized in a consistent directory structure within your bucket, making it easy to integrate with your existing data pipelines and analytics tools.


# Google Cloud Storage
Source: https://docs.tight.com/integrations/analytics/google-cloud-storage

Push accounting data directly to your Google Cloud Storage buckets

## Overview

Tight integrates directly with Google Cloud Storage to periodically upload raw accounting data to your own GCS buckets. By pushing data into your GCS infrastructure, Tight eliminates the need for your data team to build direct connections to the Tight API, allowing your team to work in the data stack they're already using.

Data is exported in [Parquet file](https://parquet.apache.org/) format on daily, weekly, or monthly intervals, including bank linkage data, invoices, lifecycle events, and transactions. Learn more about available data types and use cases in the [Data Lakes guide](/guides/business-owners/data-lakes).

## Create a Service Account

First, [create a service account](https://cloud.google.com/docs/authentication/production#create_service_account) to grant programmatic access to the Google Cloud Storage bucket.

In the Google Cloud Console, navigate to IAM & Admin → Service Accounts and click "Create Service Account". Provide a descriptive name like "tight-api-data-access" and description:

<img alt="Create Service Account" />

After entering the service account details, click "Copy to clipboard" below the email address that was created. Save this email address for later steps. Then click "CREATE AND CONTINUE" followed by "DONE".

<Tip>
  Keep the service account email address handy - you'll need it in later steps to grant bucket permissions.
</Tip>

## Create a Google Cloud Storage Bucket

Next, [create a Google Cloud Storage bucket](https://cloud.google.com/storage/docs/creating-buckets#create_a_new_bucket) where Tight will store your data. We recommend naming this bucket "tight-api-data":

<img alt="Create GCS Bucket" />

For "Choose where to store your data" and "Choose a default storage class for your data", you can use the default values.

For "Choose how to control access to objects", select "Enforce public access prevention on this bucket" and "Access Control: Fine-grained":

<img alt="Access Control Settings" />

For "Choose how to protect object data", select "None" unless your compliance requirements dictate otherwise. Be aware that data protection options will increase your storage costs.

<img alt="Protect Object Data" />

Click "CREATE" to finish creating the bucket.

## Grant Service Account Access to Bucket

Once the bucket is created, you'll be taken to the Bucket Details screen. Click on the "PERMISSIONS" tab and then click "ADD":

<img alt="Bucket Permissions" />

In the "New Principals" field, paste the service account email address you copied earlier, and set the role to "Storage Object Admin":

<img alt="Add Principals" />

Click "SAVE" to grant the service account access to your bucket.

## Create Service Account HMAC Key

Next, [create a service account HMAC key](https://cloud.google.com/storage/docs/authentication/managing-hmackeys#create) for authentication.

From the Cloud Storage screen, click on "Settings", then select the ["Interoperability" tab](https://console.cloud.google.com/storage/settings;tab=interoperability):

<img alt="Interoperability Settings" />

Click "CREATE A KEY FOR A SERVICE ACCOUNT", paste the service account email address, and select the row for that account:

<img alt="Create HMAC Key" />

Click "CREATE KEY" to generate the HMAC key. You'll see a screen displaying both the Access Key and Secret. Copy both values and save them securely:

<img alt="HMAC Key Credentials" />

<Tip>
  Store the Access Key and Secret securely - you won't be able to view the Secret again after this screen.
</Tip>

## Securely Share Access with Tight

Contact Tight directly at [api@tight.com](mailto:api@tight.com) for instructions on how to securely share:

* Your GCS bucket name
* The HMAC Access Key
* The HMAC Secret

Once configured, Tight will automatically begin uploading data files to your GCS bucket based on your preferred schedule (daily, weekly, or monthly). Files are organized in a consistent directory structure within your bucket, making it easy to integrate with your existing data pipelines and analytics tools.


# Mixpanel
Source: https://docs.tight.com/integrations/analytics/mixpanel

Analyze analytics data from Tight directly in Mixpanel

## Overview

Tight integrates directly with Mixpanel so that [actions that your users take inside Tight's embeddable user interface](/guides/business-owners/lifecycle-event-dictionary)
(or via your home-built interface on top of the Tight API) will be tracked
using [Mixpanel events](https://developer.mixpanel.com/reference/track-event). This allows you to leverage your existing
Mixpanel implementation for product analytics or add a new Mixpanel integration so that you can iterate your product
more successfully.

## Create a Mixpanel Project

If you haven't done so already, you should create a [Mixpanel account](https://mixpanel.com/register/).

## Securely sharing your Mixpanel Project Token

Once your project is created, navigate to Project Settings from your Mixpanel project dashboard. From there, copy the
Project Token and use the [Configure Mixpanel API](/api-reference/integrations/configure-mixpanel) to securely share
your Project Token.

## Identify users (optional)

If you are identifying your user with Mixpanel using something different than the `userId` that you use
to [create companies in the Tight API](/api-reference/company-management/create-a-company), then you will need
to [provide the identifier used in Mixpanel for that user](/api-reference/integration-management/link-mixpanel).


# Snowflake
Source: https://docs.tight.com/integrations/analytics/snowflake

Push accounting data directly to your Snowflake data warehouse

## Overview

Tight integrates directly with Snowflake to periodically upload raw accounting data to your own Snowflake data warehouse. By pushing data into your Snowflake infrastructure, Tight eliminates the need for your data team to build direct connections to the Tight API, allowing your team to work in the data stack they're already using.

Data is exported in [Parquet file](https://parquet.apache.org/) format on daily, weekly, or monthly intervals, including bank linkage data, invoices, lifecycle events, and transactions. Learn more about available data types and use cases in the [Data Lakes guide](/guides/business-owners/data-lakes).

## Create a Snowflake Managed Stage

If you haven't done so already, create a [Snowflake account](https://www.snowflake.com/) and [create a Snowflake Managed Stage](https://docs.snowflake.com/en/developer-guide/snowflake-cli/stages/manage-stages) where Tight will upload your data. You can name this stage anything you'd like; "TIGHT\_DATALAKE\_UPLOADS" is used for the examples shown below.

<img alt="Snowflake Stages" />

<img alt="Create Snowflake Stage" />

Make note of the database name and stage name, as you'll need to share these with Tight.

## Create Key Pair Authentication Keys

Next, [generate key pair authentication keys](https://docs.snowflake.com/en/user-guide/key-pair-auth) for secure authentication to your Snowflake account.

From the command prompt, execute the following commands:

```bash theme={null}
openssl genrsa 2048 | openssl pkcs8 -topk8 -inform PEM -out rsa_key.p8 -nocrypt
```

```bash theme={null}
openssl rsa -in rsa_key.p8 -pubout -out rsa_key.pub
```

Save both `rsa_key.p8` and `rsa_key.pub` files securely for use in later steps.

<Tip>
  Store the private key (`rsa_key.p8`) securely. You'll need to share this with Tight to enable data uploads.
</Tip>

## Create an Upload Role

Create a dedicated role for Tight to use when uploading data to your Snowflake warehouse. For example, name it `TIGHT_UPLOADER_ROLE`:

<img alt="New Snowflake Role" />

## Grant Role Permissions

Grant the necessary permissions to the `TIGHT_UPLOADER_ROLE`:

**Grant USAGE to Database:**

<img alt="Grant Data Lake Privileges" />

**Grant USAGE to the PUBLIC Schema:**

<img alt="Grant Public Privileges" />

**Grant READ/WRITE to the Stage:**

Grant read and write permissions to the stage you created (e.g., `TIGHT_DATALAKE_UPLOADS`):

<img alt="Grant Read/Write Access" />

## Create a Service User

Create a service user using Snowflake SQL. Service users with RSA authentication cannot be created through the Snowflake UI, so you'll need to execute SQL commands.

Using the public key from `rsa_key.pub` that you generated earlier, execute the following SQL statement:

```sql theme={null}
CREATE OR REPLACE USER TIGHT_UPLOADER_USER
TYPE = SERVICE
RSA_PUBLIC_KEY = '-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0chQEeQSKX3I+Y5VD3M+
kyPEbFDTgmEqxgerz3hIihUGV+iWWoHdeUYFCORfK1p/Sa3e3u79h1+hI4e9lsWU
8xLUCUlcfImbu7EbZ5oNYlhRi5nFhkqN4YlylbUghlsmJv7GK4L68i9M/WUoG9RR
yvHghltIMpwbQfRZ4wYG5Dc2sl7ZbCe8qn7VGrSzWWcex3WK9K8kbBJkK86H8X7u
L1QgY+a//s32HuBmbfV8+x4kC3oSrFhPDFJX5kJI33UPqRNyuhSZOuJMMNhXX8bh
PAKY4ExZVotEKX+p8hZ0La5N7TT+Ma08Zp9WR5YGuG2XPK+9dE2Yg9Luauc+R4hj
wwIDAQAB
-----END PUBLIC KEY-----'
DEFAULT_ROLE = 'TIGHT_UPLOADER_ROLE'
DEFAULT_WAREHOUSE = 'COMPUTE_WH'
COMMENT = 'Tight service account for uploading to stage';
```

<Tip>Replace the example RSA public key with your actual public key.</Tip>

<img alt="Tight Snowflake User" />

<Tip>
  Replace the example RSA public key with the contents of your `rsa_key.pub` file, including the BEGIN and END markers.
</Tip>

## Grant Role to Service User

Grant the `TIGHT_UPLOADER_ROLE` to your `TIGHT_UPLOADER_USER`:

<img alt="Role Specification" />

## Securely Share Access with Tight

Contact Tight directly at [api@tight.com](mailto:api@tight.com) for instructions on how to securely share:

* Snowflake account identifier (e.g., GSX\*\*\*-\*\*\*\*)
* Database name
* Schema name (typically PUBLIC)
* Stage name (e.g., TIGHT\_DATALAKE\_UPLOADS)
* Service user name (e.g., TIGHT\_UPLOADER\_USER)
* RSA private key file (`rsa_key.p8`)

Once configured, Tight will automatically begin uploading data files to your Snowflake stage based on your preferred schedule (daily, weekly, or monthly). Files are organized in a consistent directory structure within your stage, making it easy to integrate with your existing data pipelines and analytics tools.


# Finicity
Source: https://docs.tight.com/integrations/banking/finicity

Sync transaction data directly from Finicity

## Overview

Through Tight's Finicity integration, your users' transactions are pushed into Tight immediately after Finicity has
cleansed them. All of those transactions are then run through Tight's proprietary algorithms, which leverage the user's
business type, accountant best practices, and the behavior of similar businesses.

## Push transactions into the Tight API

Once you have received your cleansed transactions from Finicity, you
can forward the transaction data directly to [Tight's Finicity Transactions API](/api-reference/integration-management/finicity-transactions).


# MX
Source: https://docs.tight.com/integrations/banking/mx

Sync transaction data directly from MX

## Overview

Through Tight's MX integration, your users' transactions are pushed into Tight immediately after MX has
cleansed them. All of those transactions are then run through Tight's proprietary algorithms, which leverage the user's
business type, accountant best practices, and the behavior of similar businesses.

## Push transactions into the Tight API

Once you have received your cleansed transactions from MX, you
can forward the transaction data directly to [Tight's MX Transactions API](/api-reference/integration-management/mx-transactions).


# Plaid
Source: https://docs.tight.com/integrations/banking/plaid

Enable your users to sync and manage their bank connections

## Overview

Instead of having to build your own architecture to manage Plaid linkage and transactions, you can leverage Tight's
proven architecture to communicate directly with Plaid on your behalf. Once configured, Tight's Plaid integration
provides:

* A seamless UX for your users to connect and manage their bank connections
* Intuitive UX to walk your users through fixing connection issues on their own
* Webhook handling to process newly available transactions in real-time
* Automatic transaction categorization, with full double-entry accounting

## Create a Plaid Team

If you haven't done so already, Tight can introduce you to Plaid to get your team registered quickly. Once you have
access to the Plaid Dashboard, be sure to
enable [Account Select](https://plaid.com/docs/link/customization/#account-select) so that your users can select which
bank accounts to link to their accounting platform.

## Securely sharing your Plaid keys

In your Plaid Dashboard, to view your API keys, click on Team Settings -> Keys. Use
the [Configure Plaid API](/api-reference/integrations/configure-plaid) to securely share your keys.

Once complete, the Tight Embedded UI will automatically allow your users to link their bank accounts and start syncing
bank transactions.

## Connect your user's Plaid accounts

There are three primary ways to connect your users' Plaid accounts to their company in Tight:

1. Embedding Tight's [Financial Overview](/embeddable-ui/react/financial-overview), which includes all onboarding tasks, including Plaid linkage
2. Embed Tight's [Banks & Integrations](/embeddable-ui/react/banks-and-integrations) page, which includes Plaid linkage as well as any other native integrations you choose to enable
3. Or, if you already handle Plaid linkage in your UX, you can [programmatically link the user's Plaid accounts](/api-reference/integration-management/link-plaid)

## Go Live in Production

Before allowing users to link accounts in production:

1. [Request Production access](https://dashboard.plaid.com/overview/production), then complete your
   [application profile](https://dashboard.plaid.com/settings/company/app-branding),
   [company profile](https://dashboard.plaid.com/settings/company/profile), and
   [security questionnaire](https://dashboard.plaid.com/settings/company/compliance?tab=dataSecurity). Some financial
   institutions require this information for OAuth connections. See Plaid's
   [Launch in Production checklist](https://plaid.com/docs/launch-checklist/) for the complete set of launch
   recommendations.
2. Open the [Data Transparency Link Customization](https://dashboard.plaid.com/link/data-transparency-v5). For each
   Link customization your app uses, select one to three use case descriptions that accurately explain how your app
   uses financial data, then publish the changes. For example, apps that use Tight for bookkeeping and tax features
   can select **Do business accounting and tax preparation**.

<Warning>
  If Data Transparency Messaging is enabled but a Link customization has no published use case, Plaid rejects
  production Link requests with the `INVALID_LINK_CUSTOMIZATION` error.
</Warning>

### Get access to bank statements \[Optional]

Before enabling [Plaid Statements](https://plaid.com/docs/statements/) in production, submit a
[Plaid support ticket](https://dashboard.plaid.com/support/new) and explicitly request direct access for Chase. Wait
for Plaid to confirm access before enabling Statements for your production users.


# Unit
Source: https://docs.tight.com/integrations/banking/unit

Sync your users' banking data to their accounting platform in real time

## Overview

[Tight partners with Unit](https://www.unit.co/docs/guides/partnerships/tight/) to automatically sync your users'
banking data directly into their books.

## Securely sharing your Unit partner token

Email your contact at Unit to request that they
grant [Partner Token](https://guides.unit.co/partnerships/partner-tokens/#overview) access to Tight. Unit will then
securely give Tight partner token access to your Unit bank accounts for the `accounts` and `transactions` scopes.

## Unit webhooks (real-time updates)

By subscribing the Tight API to receive webhooks on your Unit dashboard, Tight will be able to pull in updates to your
users' transactions in real-time.

To do so, in your Unit Dashboard, click on Developer -> Webhooks.

<img alt="Unit Dashboard" />

Next, click on "Create", which will open up the "Create new webhook" form. Fill in the fields as shown in the screenshot
below:

<img alt="Unit Webhook Configuration" />

Use
the [Configure Unit API](/api-reference/integrations/configure-unit) to securely share your keys.

## Connect your user's Unit customer

To associate a Unit customer with your user's company in Tight, simply hit
the [Link Unit API](/api-reference/integration-management/link-unit)


# Fundbox
Source: https://docs.tight.com/integrations/capital/fundbox

Offer capital at opportune moments, backed by real-time accounting data

<Warning>
  This page is under construction. Please check back later for more content.
</Warning>


# Parafin
Source: https://docs.tight.com/integrations/capital/parafin

Offer capital at opportune moments, backed by real-time accounting data

<Warning>
  This page is under construction. Please check back later for more content.
</Warning>


# Pipe
Source: https://docs.tight.com/integrations/capital/pipe

Offer capital at opportune moments, backed by real-time accounting data

<Warning>
  This page is under construction. Please check back later for more content.
</Warning>


# Stripe Capital
Source: https://docs.tight.com/integrations/capital/stripe-capital

Offer capital at opportune moments, backed by real-time accounting data

<Warning>
  This page is under construction. Please check back later for more content.
</Warning>


# Rutter
Source: https://docs.tight.com/integrations/commerce/rutter

Automate the reconciliation between commerce platform payouts and their itemized transactions with Tight via Rutter's unified API

## Overview

Instead of building separate integrations with dozens of commerce platforms in-house, Tight communicates with multiple
commerce platforms through [Rutter](https://www.rutter.com/), a unified commerce API. Rutter connects to platforms like
Shopify, Amazon, WooCommerce, BigCommerce, and many others, enabling you to provide your customers with seamless
commerce integrations while getting automatic invoice, payment, and payout reconciliation on their books.

With Rutter, you own the relationship between your customer and their commerce platforms, while Tight handles the
complexity of automated reconciliation across all their sales channels.

## Automated Reconciliation

Commerce platforms deposit money directly into your users' bank accounts on a regular cadence. When utilizing one of the Tight
Bank Transactions integrations, e.g. [Plaid](/integrations/banking/plaid), the bank deposit to the user's bank account
will also be ingested by the Tight API as part of that integration's bank feed. Importantly, Tight's algorithms automate
the reconciliation between that bank deposit and the itemized transactions within the commerce platform, saving your
users time that would have otherwise been spent manually reconciling these transactions in legacy accounting systems.

### Multi-Platform Order Payout Example

1. The business owner processes orders across multiple platforms through Rutter-connected channels (e.g., Shopify online
   store, Amazon marketplace, WooCommerce site).
2. These orders are automatically synced into Tight as invoices through Rutter's unified API.
3. Customers pay for their orders via various payment methods. Each platform deducts processing fees and marketplace
   fees from payments.
4. Each platform groups payments into periodic payouts according to their individual schedules.
5. The user receives separate payouts from each platform (e.g., \$3,850 from Shopify, \$2,100 from Amazon), also seen as
   deposits into their checking account.
6. The Tight API automatically matches the synced invoices with the corresponding payouts across platforms, creates
   expenses for all processing fees and marketplace commissions, and reconciles the net amounts. Additionally, the Tight
   Embedded experience nests these transaction line items neatly under their respective payout rows.

## Supported Commerce Platforms

Through Rutter's unified API, Tight supports automatic reconciliation for:

* **Shopify** - Online store orders, payments, and payouts
* **Amazon** - Marketplace orders, settlements, and fees
* **WooCommerce** - WordPress-based e-commerce transactions
* **BigCommerce** - Multi-channel commerce orders
* **Squarespace** - Website commerce transactions
* **Square** - Point-of-sale and online orders
* **Etsy** - Marketplace sales and payments
* **eBay** - Auction and fixed-price listings
* And many more platforms supported by Rutter

## Create a Rutter Account

If you haven't already, sign up for a [Rutter](https://dashboard.rutter.com/signup) developer account. Once created,
you'll have access to the Rutter dashboard where you can configure your integration settings.

### Setup Rutter OAuth

Tight's Rutter integration utilizes OAuth 2.0 to read your users' commerce data across multiple platforms. Navigate to your
Rutter dashboard to configure OAuth.

#### Step 1: Enable Production Access

Request Production access for your account from Rutter [here](https://dashboard.rutterapi.com/request-access).

#### Step 2: Enable Commerce Platforms

In your Rutter dashboard, navigate to the Platforms section and enable the commerce platforms you want to support for
your users. Some platforms may require you to create a developer account with that platform and provide platform-specific
credentials.

Rutter provides detailed setup guides for each platform in their [documentation](https://docs.rutter.com/supported-platforms).

#### Step 3: Connect Tight Webhook URLs (Real-Time Updates)

By subscribing the Tight API to receive webhooks from Rutter, Tight will be able to pull in updates to your users'
commerce data in real-time as they occur across all connected platforms.

To configure webhooks, navigate to the Webhook Configuration section in your Rutter dashboard and add
`https://webhook.sandbox.tight.com/rutter` as your webhook URL.

<img alt="Rutter Webhook Settings" />

#### Step 4: Production Setup

Once you are ready to go live in the Production environment, update your Rutter dashboard settings with the following
production URLs:

* **Webhook URL**: `https://webhook.prod.tight.com/rutter`

Ensure your production Rutter account has the same platform enablements and webhook configurations as your sandbox
environment.

## Securely share your Rutter keys

Navigate to the API Keys section in your Rutter dashboard to note down your "Client ID" and "Client Secret" keys, which you'll need to provide to
Tight.

<img alt="Rutter Sandbox Mode Settings" />

<img alt="Rutter Production Mode Settings" />

<Info>
  Note that the `client_id` remains the same between Production and Sandbox mode, but the `client_secret` keys are separate between modes. You can toggle between the two modes via the dropdown on the top left of the Rutter Dashboard.
</Info>

Once you've collected your Client ID and Client Secret from the Rutter dashboard, use the Tight API
to [configure your Rutter integration](/api-reference/integrations/configure-rutter) for both Production and Sandbox environments.

The configuration will securely store your Rutter credentials and enable the integration for your users.

## Connect your user's commerce accounts

There are two primary ways to connect your users' commerce platform accounts to their company in Tight via Rutter:

1. Tight's Embedded UI provides UX from which users can kick off the Rutter connection flow, e.g. when onboarding
   in the [Transaction Dashboard](/embeddable-ui/react/bank-transactions/transactions-dashboard). Users can select which
   commerce platform they want to connect from the available options.

2. Programmatically [link the user's Rutter connection](/api-reference/integration-management/link-rutter) to Tight using a `public_token` value obtained from [Rutter's Connections API](https://docs.rutter.com/rest/2023-03-14/connections#create-a-connection).


# Shopify
Source: https://docs.tight.com/integrations/commerce/shopify

Automate the reconciliation between Shopify payouts and their itemized transactions with Tight

## Overview

Instead of building an integration with Shopify in-house, Tight communicates directly with Shopify on your behalf using
your [Shopify Partner](https://www.shopify.com/partners) account. This enables you to own the relationship between your
customer and Shopify while getting automatic order, payment, and payout reconciliation on the user's books.

## Automated Reconciliation

Shopify deposits money directly into your users' bank accounts on a regular cadence. When utilizing one of the Tight Bank
Transactions integrations, e.g. [Plaid](/integrations/banking/plaid), the bank deposit to the user's bank account will
also be ingested by the Tight API as part of that integration's bank feed. Importantly, Tight's algorithms automate the
reconciliation between that bank deposit and the itemized transactions within Shopify, saving your users time that would
have otherwise been spent manually reconciling these transactions in legacy accounting systems.

### Order Payout Example

1. The business owner processes 4 orders of \$1000 each through their Shopify store (e.g., online orders, point-of-sale
   transactions, mobile app sales).
2. These 4 Shopify orders are automatically synced into Tight as invoices.
3. Customers pay for their orders via 4 separate credit card payments. Shopify Payments deducts processing fees from
   each payment (2.9% + \$0.30 per transaction = \$29.30 per payment for merchants on the Basic plan).
4. Shopify groups these payments (now \$970.70 each after fees) into a single payout based on the merchant's payout
   schedule.
5. The user receives a payout from Shopify for \$3882.80 (\$4000 minus \$117.20 in processing fees), also seen as a
   \$3882.80 deposit into their checking account.
6. The Tight API automatically matches the 4 synced invoices with the one payout, and creates expenses for the
   processing fees deducted from each payment. Additionally, the Tight Embedded experience nests these transaction line
   items neatly under a single payout row.

## Create a Shopify App

If you haven't already, sign up for a [Shopify Partner](https://www.shopify.com/partners) account. Once created, you
can create a new Shopify app from the Partner Dashboard.

### Setup Shopify App

Tight's Shopify integration utilizes OAuth 2.0 to read your users' store data. Once your Shopify app is created, configure the following settings.

#### Step 1: Configure App Access Scopes

Your app will need access to the following scopes to enable Tight's integration:

* `read_all_orders` - To sync order data
* `read_products` - To access product information
* `read_shopify_payments_payouts` - To retrieve payout data
* `read_customers` - To access customer information associated with orders

#### Step 2: Configure Redirects

For the OAuth redirect URLs, add `https://redirect.sandbox.tight.com/integrations/shopify` and
`https://redirect.prod.tight.com/integrations/shopify` since Shopify does not have separate sandbox and production
environments.

<img alt="Shopify Config" />

#### Step 3: Note Your Credentials

From the developer dashboard settings, note down your Client ID and Client Secret which you'll need to provide to Tight.

## Securely share your Shopify credentials

Once you've collected your Client ID and Client Secret from the Shopify Partner Dashboard, use the Tight API
to [configure your Shopify integration](/api-reference/integrations/configure-shopify).

## Connect your users' Shopify stores

There are three primary ways to connect your users' Shopify stores to their company in Tight:

1. For partners including commerce platform linkage from their own UX, use
   the [Start Shopify Flow API](/api-reference/integration-management/start-shopify-flow) which wraps the entire OAuth
   2.0 flow such that you simply need to redirect your user to a single URL.
2. Tight's Embedded UI also provides UX from which users can kick off the Shopify connection flow, e.g. when onboarding
   in the [Transaction Dashboard](/embeddable-ui/react/bank-transactions/transactions-dashboard)
3. For partners with existing Shopify
   integrations, [programmatically link the user's Shopify store](/api-reference/integration-management/link-shopify)


# Square
Source: https://docs.tight.com/integrations/commerce/square

Automate the reconciliation between Square payouts and their itemized transactions with Tight

## Overview

Instead of building an integration with Square in-house, Tight communicates directly with Square on your behalf using
your [Square Developer](https://developer.squareup.com/us/en) account. This enables you to own the relationship between
your customer and Square, while getting automatic invoice, payment, and payout reconciliation on the user's books.

## Automated Reconciliation

Square deposits money directly into your users' bank accounts on a regular cadence. When utilizing one of the Tight Bank
Transactions integrations, e.g. [Plaid](/integrations/banking/plaid), the bank deposit to the user's bank account will
also be ingested by the Tight API as part of that integration's bank feed. Importantly, Tight's algorithms automate the
reconciliation between that bank deposit and the itemized transactions within Square, saving your users time that would
have otherwise been spent manually reconciling these transactions in legacy accounting systems.

### Order Payout Example

1. The business owner processes 4 orders of \$1000 each through Square (e.g., point-of-sale transactions, online orders,
   invoices).
2. These 4 Square orders are automatically synced into Tight as invoices.
3. Customers pay for their orders via 4 separate credit card payments. Square deducts processing fees from each payment
   (2.9% + \$0.30 per transaction = \$29.30 per payment).
4. Square groups these payments (now \$970.70 each after fees) into a single payout.
5. The user receives a payout from Square for \$3882.80 (\$4000 minus \$117.20 in processing fees), also seen as a
   \$3882.80
   deposit into their checking account.
6. The Tight API automatically matches the 4 synced invoices with the one payout, and creates expenses for the
   processing
   fees deducted from each payment. Additionally, the Tight Embedded experience nests these transaction line items
   neatly
   under a single payout row.

## Create a Square Application

If you haven't already, sign up for a [Square Developer](https://developer.squareup.com/us/en) account. Once created,
add a new Square application from the developer console.

### Setup Square OAuth

Tight's Square integration utilizes OAuth 2.0 to read your users' seller data. Once your Square application is
created, navigate to the OAuth menu item from the navigation bar.

#### Step 1: Configure Redirects

For the OAuth redirect URLs, add `https://redirect.sandbox.tight.com/integrations/square`.

While there, please note down the "Application ID" and the "Application Secret."

<img alt="Square OAuth Settings" />

#### Step 2: Connect Tight Webhook URLs (Real-Time Updates)

By subscribing the Tight API to receive webhooks on your Square dashboard, Tight will be able to pull in updates to your
users' commerce data in real-time.

To do so, click on "Webhooks" then "Add subscription" which will open a new webhook form. Provide a name and specify
the notification URL as `https://webhook.sandbox.tight.com/square`. Be sure to enable all Customers, Invoices, Orders,
Payments, Payouts, Refunds, and Vendors events.

<img alt="Square Webhook Settings" />

#### Step 3: Production Setup

Once you are ready to go live in the "Production" environment, toggle to Production and add the following OAuth redirect
URL: `https://redirect.prod.tight.com/integrations/square`. Additionally, configure a webhook subscription for
`https://webhook.prod.tight.com/square` with the same set of events.

## Securely share your Square keys

The last field that is needed is a "Secret key", which you can find on
the [API keys](https://dashboard.square.com/test/apikeys) page. Under the "Standard keys" section, you will see a "
Secret key" row. You should note down the `token` field for the Secret key.

Once collected, use the Tight API to [configure your Square integration](/api-reference/integrations/configure-square).

## Connect your user's Square accounts

There are three primary ways to connect your users' Square accounts to their company in Tight:

1. For partners including commerce platform linkage from their own UX, use
   the [Start Square Flow API](/api-reference/integration-management/start-square-flow) which wraps the entire OAuth 2.0
   flow such that you simply need to redirect your user to a single URL.
2. Tight's Embedded UI also provides UX from which users can kick off the Square connection flow, e.g. when onboarding
   in the [Transaction Dashboard](/embeddable-ui/react/bank-transactions/transactions-dashboard)
3. For partners with existing Square
   integrations, [programmatically link the user's Square account](/api-reference/integration-management/link-square)


# Custom Integrations
Source: https://docs.tight.com/integrations/custom-integrations

Allow Tight to ingest granular data already stored in your platform

Tight enables custom integrations to ingest granular data already stored in your platform (e.g. invoices and line items
stored in a vertical SaaS platform, dimension hierarchies like cost centers, regions, locations, departments, etc.).

The Tight team will create a custom implementation plan for your specific platform to ensure any financial data stored
in your platform flows into your new accounting product. For example, the invoices tracked in your system are
automatically reconciled with the bank deposits flowing into Tight.


# Front
Source: https://docs.tight.com/integrations/customer-service/front

Streamline communication between business owners and bookkeepers

## Overview

Instead of building a customer support integration in-house, Tight integrates directly
with [Front](https://front.com/teams/customer-support) to facilitate transaction-level communication between bookkeepers
and business owners. This enables contextual collaboration where bookkeepers can ask questions about specific
transactions without copying data or switching between workspaces.

Through this native integration, bookkeepers can select transactions within Tight's embeddable UI and prefill messages
with transaction details. Tight automatically forwards these messages to Front and routes responses back to the
appropriate bookkeeper. Business owners communicate via their preferred method (email), without knowing Front is being
used behind the scenes.

## Getting started

If you haven't already done so, you should [create a Front account](https://front.com/#get-started) for your
company/app.

## Create a Communication Channel

After you have created your Front account, you will need to create a Channel from
your [Front settings](https://app.frontapp.com/settings/). A Channel represents the method through which your
bookkeepers will communicate to your users, all via a single point of contact from your users’ perspective. For example,
your users might receive emails from `bookkeepers@bookkeepingCo.com`, even though multiple bookkeepers are communicating
through that same Channel. During Channel creation, Front will also walk you through how to set up an Inbox, which is
how Front will group conversations with your clients.

## Create Front API Token

Navigate to the "API Tokens" tab of
your [Front developer settings](https://app.frontapp.com/settings/developers/tokens). You can then create a token with a
name like "Tight Token", and ensure that you pick the "Shared Resources" scope. You should note down the `API Token`
field after creation.

<img alt="Front API Token" />

## Securely share your Front credentials

Once you have collected your API Token and Channel name, use
the [Configure Front API](/api-reference/integrations/configure-front) to securely share your Front credentials with
Tight.


# Intercom
Source: https://docs.tight.com/integrations/customer-service/intercom

Provide customer support, engage customers through lifecycle messaging, and track useful analytics

## Overview

Tight integrates directly with Intercom so that actions that your users take inside Tight's embeddable user interface (or via your home-built interface on top of the Tight API) will be tracked using [Intercom events](https://developers.intercom.com/docs/references/rest-api/api.intercom.io/Events/event/). This allows you to leverage your existing Intercom integration or add a new Intercom integration so that you can:

* Provide targeted customer support based on user actions in Tight
* Trigger lifecycle messaging campaigns based on accounting activity
* Track product analytics and user engagement
* Build custom workflows and automations in Intercom

## Create an Intercom Workspace

If you haven't done so already, you should create an [Intercom account](https://www.intercom.com/signup) and set up a workspace for your application.

## Securely sharing your Intercom App ID

Copy the App ID and use the [Configure Intercom API](/api-reference/integrations/configure-intercom) to securely share your App ID with Tight.

## Identify users (optional)

If you are identifying your users in Intercom using something different than the `userId` that you use to [create companies in the Tight API](/api-reference/company-management/create-a-company), then you will need to [provide the identifier used in Intercom for that user](/api-reference/integration-management/link-intercom).

This ensures that events from Tight are properly attributed to the correct user profile in Intercom.


# Twilio
Source: https://docs.tight.com/integrations/customer-service/twilio

Enable Agentic Accountants to efficiently manage the books via quick text messages to business owners

## Overview

Tight integrates with Twilio to send RCS and SMS messages to business owners as needed, to ensure efficient onboarding, activation, and book maintenance.

### Onboarding & Activation

* Link bank account
* If migrating, link legacy accounting platform (e.g. QuickBooks Online, Xero, Wave)

### Book Maintenance

* Ask questions on ambiguous transactions (e.g. Zelle Deposits, Checks with no description, etc.)
* Monthly financial summary delivery
* Bank connection issues requiring action
* Other configurable accounting milestones

## Integrating Twilio

### Create a Twilio Account

If you don't have one already, [sign up for a Twilio account](https://www.twilio.com/try-twilio).

### Get a Phone Number

You need a Twilio phone number that Tight will use to send SMS messages to your business owners.

1. From the [Twilio Console](https://console.twilio.com), go to **Phone Numbers** > **Manage** > **Buy a number**
2. Filter by **SMS** capability and select a number
3. Purchase the number and copy it in [E.164 format](https://www.twilio.com/docs/glossary/what-e164) (e.g.,
   `+12025551234`)

### Retrieve Your Credentials

From the [Twilio Console Dashboard](https://console.twilio.com):

1. Copy your **Account SID** (begins with `AC`)
2. Reveal and copy your **Auth Token**

### Share Your Credentials with Tight

Use the [Configure Twilio API](/api-reference/integrations/configure-twilio) to securely share your Account SID, Auth
Token, and phone number (or Messaging Service SID) with Tight.


# Native Integrations
Source: https://docs.tight.com/integrations/native-integrations

Leverage the Tight API’s wide range of seamless integrations

## Zero dev effort

All of Tight's integrations are native integrations such that your company will not need to pull or push any data from
the integration provider.

For example, if you want to integrate bank transactions (via [Plaid](/integrations/banking/plaid)), you can simply
provision a Plaid developer account and grant Tight partner-level access to that account, and Tight takes care of the
rest; no infrastructure for your team to build around pulling/storing/refreshing tokens and handling error scenarios.

If you want to integrate tax filings (via [April](/integrations/tax/april)), you can simply provision a Column
Tax developer account and grant Tight partner-level access to that account, and Tight takes care of the rest; no need
for your team to aggregate all the user's transactions and push them into Column Tax's API directly.

## Own the relationships with your providers

The Tight API serves as the general ledger and glue for all of the accounting data that your users accumulate. All the
relationships (and any associated economics) with integration partners like Plaid, Column Tax, Stripe, etc. are owned by
your company, giving you the same flexibility you would get if working with those integrations directly, but without any
of the development/integration overhead.

## One-stop shop

By enabling the integrations that make sense for your user base, you enable your platform to become the true one-stop
shop that every business owner is after.

<Note>
  If you don't see an integration that you're looking for, don't hesitate to reach out to the Tight team at [api@tight.com](mailto:api@tight.com). Tight is architected to support infinite integrations and is always adding new integrations based on customer-partner demand.
</Note>


# Adyen
Source: https://docs.tight.com/integrations/payment-processing/adyen

Automate the reconciliation between Adyen payouts and their itemized transactions with Tight

## Overview

Instead of building an integration with Adyen in-house, Tight communicates directly with Adyen on your behalf using
your [Adyen platform](https://www.adyen.com/platform-payments) account. This enables you to own the relationship between
your customer and Adyen, including any associated economic benefits, while getting a seamless invoicing user experience with
automatic payout reconciliation on the user's books.

## Automated Reconciliation

Adyen deposits money directly into your users' bank accounts on a regular cadence. When utilizing one of the Tight Bank
Transactions integrations, e.g. [Plaid](/integrations/banking/plaid), this deposit will also be ingested by the Tight
API as part of that integration. Importantly, Tight's integration with Adyen operates at the platform level, allowing
Tight to reconcile the Balance Platform fees alongside the associated payments and ultimately the payouts to the
end-user's bank accounts and the transaction data from Plaid, saving your users time that would have otherwise been
spent manually reconciling these transactions in legacy accounting systems.

See the [**Invoice Payout Example**](/guides/business-owners/invoicing#invoice-payout-example) to understand the level
of complexity that Tight automates.

## Become an Adyen Platform

If you haven't already done so, you should [create an Adyen account](https://www.adyen.com/signup) for your
company/app.


# Moov
Source: https://docs.tight.com/integrations/payment-processing/moov

Enable your users to collect invoice payments via credit card through Moov

## Overview

Instead of building an integration with Moov in-house, Tight communicates directly with Moov on your behalf using
your [Moov facilitator](https://moov.io/) account. This enables you to own the relationship between your customer and
Moov, including any associated economic benefits, while getting a seamless invoicing user experience with automatic
payment reconciliation on the user's books.

## Automated Reconciliation

Moov processes credit card payments for invoices sent by your users. When utilizing one of the Tight Bank Transactions
integrations, e.g. [Plaid](/integrations/banking/plaid), the bank deposit to the user's bank account will also be
ingested by the Tight API as part of that integration's bank feed. Importantly, Tight's algorithms automate the
reconciliation between that bank deposit and the itemized transactions within Moov, saving your users time that would
have otherwise been spent manually reconciling these transactions in legacy accounting systems.

See the [**Invoice Payout Example**](/guides/business-owners/invoicing#invoice-payout-example) to understand the level
of complexity that Tight automates.

## Create a Moov Account

If you haven't done so already, Tight can introduce you to Moov to get your team registered quickly. Alternatively, you
can [create a Moov account](https://dashboard.moov.io/signup) directly for your company/app.

## Setup Moov Integration

When you first access your Moov account dashboard, the header will display "Viewing test account", indicating you're
in [Moov's Test mode](https://docs.moov.io/guides/set-up-your-account/test-mode/). Complete the following setup steps in
Test mode first.

### Step 1: Create API Keys

1. Navigate to Developers > API Keys from the left-hand navigation pane
2. Click the "New API key" button on the top right
3. In the "Name" field, add a descriptive name
4. Under "Domains", add your application's domains
5. Click "Create API key"
6. Note down the "Public key" and "Secret key" shown, as they will only be displayed once

<img alt="Moov API Keys" />

### Step 2: Configure Webhooks

Webhooks enable Tight to receive real-time updates about payment events from Moov.

1. Navigate to Developers > Webhooks from the left-hand navigation pane
2. Click the "New webhook" button on the top right
3. Configure the webhook:
   * **Endpoint URL (Sandbox)**: `https://webhook.sandbox.tight.com/moov`
   * **Endpoint URL (Production)**: `https://webhook.prod.tight.com/moov`
   * **Description**: "Webhook for Tight API"
   * **Events to send**: Select "All events"
4. Click "Create webhook"

<img alt="Moov Webhook Settings" />

### Step 3: Get Facilitator Account ID

1. Navigate to Settings > Business details from the left-hand navigation pane
2. Note down the "Account ID" displayed - this is your Moov facilitator account ID

## Configure Fee Schedule

As the facilitator of payments between your users (merchants) and their clients, you can monetize your payment flows by
collecting fees. Your fee structure should be finalized with your Moov point-of-contact. If you need an introduction to
a Moov representative, contact Tight support.

Your fee schedule consists of:

* **Moov's base fee** - Fixed fee per payment charged by Moov
* **Your base fee** - Additional fixed fee per payment (optional)
* **Moov's percentage fee** - Percentage of payment amount charged by Moov
* **Your percentage fee** - Additional percentage of payment amount (optional)

<Note>
  Your users will only see the total base fee (Moov's + yours) and total percentage fee (Moov's + yours) when processing payments.
</Note>

## Securely Share Your Moov Credentials

Once you have collected all the required information, use
the [Configure Moov API](/api-reference/integrations/configure-moov) to securely share your Moov credentials with Tight:

* Moov facilitator Account ID
* Public key and Secret key from API Keys
* Complete fee schedule (base fees and percentage fees)


# Qualpay
Source: https://docs.tight.com/integrations/payment-processing/qualpay

Enable your users to collect invoice payments via credit card and ACH through Qualpay

## Overview

Instead of building an integration with Qualpay in-house, Tight communicates directly with Qualpay on your behalf using
your [Qualpay partner](https://www.qualpay.com/payments) account. This enables you to own the relationship between your
customer and Qualpay, including any associated economic benefits, while getting a seamless invoicing user experience
with automatic payment reconciliation on the user's books.

## Automated Reconciliation

Qualpay processes credit card and ACH payments for invoices sent by your users. When utilizing one of the Tight Bank
Transactions integrations, e.g. [Plaid](/integrations/banking/plaid), the bank deposit to the user's bank account will
also be ingested by the Tight API as part of that integration's bank feed. Importantly, Tight's algorithms automate the
reconciliation between that bank deposit and the itemized transactions within Qualpay, saving your users time that would
have otherwise been spent manually reconciling these transactions in legacy accounting systems.

See the [**Invoice Payout Example**](/guides/business-owners/invoicing#invoice-payout-example) to understand the level
of complexity that Tight automates.

## Create a Qualpay Account

If you haven't done so already, Tight can introduce you to Qualpay to get your team registered quickly. Alternatively,
you can [create a Qualpay sandbox account](https://app-test.qualpay.com/login/signup) directly for your company/app.

## Setup Qualpay Integration

Start by setting up your Qualpay integration in the sandbox environment. Once you have access to your Qualpay partner
account, complete the following setup steps.

### Step 1: Create API Profile

1. Click on the "Administration" tab in the left navigation
2. Navigate to [APIs & Security](https://app-test.qualpay.com/partner/admin/security)
3. Click the "New API Profile" button on the top right
4. Name the profile (e.g., "Tight API Profile")
5. Note down the "Security Key" displayed - it will only be shown once
6. Note down the "Integrator ID" displayed

<Tip>
  Save both your Security Key and Integrator ID securely - the Security Key cannot be retrieved after initial creation.
</Tip>

### Step 2: Configure Webhooks (Real-Time Updates)

If Qualpay offers webhook functionality for real-time payment updates, configure webhooks to point to:

* **Sandbox**: `https://webhook.sandbox.tight.com/qualpay`
* **Production**: `https://webhook.prod.tight.com/qualpay`

Webhooks enable Tight to receive real-time updates about payment events from Qualpay.

## Securely Share Your Qualpay Credentials

Once you have collected your Security Key and Integrator ID, use
the [Configure Qualpay API](/api-reference/integrations/configure-qualpay) to securely share your Qualpay credentials
with Tight.


# Stripe
Source: https://docs.tight.com/integrations/payment-processing/stripe

Automate the reconciliation between Stripe payouts and their itemized transactions with Tight

## Overview

Instead of building an integration with Stripe in-house, Tight communicates directly with Stripe on your behalf using
your [Stripe platform](https://stripe.com/docs/connect) account. This enables you to own the relationship between your
customer and Stripe, including any associated economic benefits, while getting a seamless invoicing user experience with
automatic payout reconciliation on the user's books.

## Automated Reconciliation

Stripe deposits money directly into your users' bank accounts on a regular cadence. When utilizing one of the Tight Bank
Transactions integrations, e.g. [Plaid](/integrations/banking/plaid), the bank deposit to the user's bank account will
also be ingested by the Tight API as part of that integration's bank feed. Importantly, Tight's algorithms automate the
reconciliation between that bank deposit and the itemized transactions within Stripe, saving your users time that would
have otherwise been spent manually reconciling these transactions in legacy accounting systems.

See the [**Invoice Payout Example**](/guides/business-owners/invoicing#invoice-payout-example) to understand the level
of complexity that Tight automates.

## Become a Stripe Platform

If you haven't already done so, you should [create a Stripe account](https://dashboard.stripe.com/register) for your
company/app. Once you have created a Stripe account, some admin-only confirmation is required:

### Enable Stripe Connect

Stripe Connect is what allows your app to facilitate payments so that your customers can accept invoice payments from
their clients.

#### Step 1: Create Stripe Account

After you have created your Stripe account,
you will want to enable Stripe Connect by clicking the "Get Started" button on
the [Connect tab of your Stripe dashboard](https://dashboard.stripe.com/test/connect/accounts/overview) and following
the steps.

Once you have activated Stripe Connect, you should navigate to the Connect settings screen, where you will be prompted
to
enter company-specific info, including your brand colors.

#### Step 2: Enable OAuth

Once completed, on the top right of the header, you can click "Test mode", to toggle into the sandbox environment. Next,
you should navigate to the [Connect Settings screen](https://dashboard.stripe.com/settings/connect). From there, click
into "Onboarding options", then to the "OAuth" tab. Toggle on the "Enable OAuth" option.

<img alt="Stripe Onboarding Options" />

#### Step 3: Configure Redirects

Next, under "Redirects", you should add `https://redirect.sandbox.hurdlr.com/integrations/stripe`.

Please note down the "Test client ID".

#### Step 4: Production Setup

Once you are ready to go live in the "Production" environment, on the top right of the header, you can disable the "Test
mode" toggle, and repeat the above steps. Under "Redirects", you should add
`https://redirect.prod.hurdlr.com/integrations/stripe`.

### Connect Tight Webhook URLs to Stripe (Real-Time Updates)

By subscribing the Tight API to receive webhooks on your Stripe dashboard, Tight will be able to pull in updates to your
users' invoice updates in real-time.

To do so, in your Stripe Dashboard, click on Developer -> Webhooks.

<img alt="Stripe Webhooks" />

Then, click into "Add endpoint". Under the "Select events" section, be sure to select all the "Charge", "Payment
Intent", and "Payout" events, then click "Continue".

<img alt="Stripe Webhook Events" />

Finally, you will add your Tight Webhook URL for the Sandbox environment or your Webhook URL for the Production
environment, and finish by clicking "Create destination".

For Test mode, add `https://webhook.sandbox.hurdlr.com/stripe`.

For Live mode, add `https://webhook.prod.hurdlr.com/stripe`.

<img alt="Stripe Webhook Configuration" />

## Securely share your Stripe keys

The last field that is needed is a "Secret key", which you can find on
the [API keys](https://dashboard.stripe.com/test/apikeys) page. Under the "Standard keys" section, you will see a "
Secret key" row. You should note down the `token` field for the Secret key.

Once collected, use the Tight API to [configure your Stripe integration](/api-reference/integrations/configure-stripe).

## Connect your user's Stripe accounts

There are three primary ways to connect your users' Stripe accounts to their company in Tight:

1. For partners including Payment Processing linkage from their own UX, use
   the [Start Stripe Flow API](/api-reference/integration-management/start-stripe-flow) which wraps the entire OAuth 2.0
   flow such that you simply need to redirect your user to a single URL
2. Tight's Embedded UI also provides UX from which users can kick off the Stripe connection flow, e.g. when onboarding
   in the [Invoice Dashboard](/embeddable-ui/react/invoicing/invoice-dashboard)
3. For partners with existing Stripe
   integrations, [programmatically link the user's Stripe account](/api-reference/integration-management/link-stripe)


# Check
Source: https://docs.tight.com/integrations/payroll/check

Simplify the complex accounting that payroll necessitates with Tight

## Overview

Tight communicates directly with Check to automatically account for payroll directly in your users' books, including
automatically reconciling bank withdrawals against the payroll entries in real-time.

## Automated Reconciliation

In addition to a seamless UX, you and your users can rest assured knowing that the complex accounting that payroll
necessitates is automatically taken care of. When your user runs a payroll, the necessary accounting transactions are
automatically created in the user's General Ledger. Furthermore, when the bank withdrawals come in several days later,
the Tight API will automatically reconcile those with the payroll run, keeping the user's General Ledger and balance
sheets in sync, without any manual labor required from your user.

That reconciliation process, when done manually, can be very complex, as a single Check payroll run and the subsequent
withdrawal need to be split over many different accounts. With the Tight API, this reconciliation happens
automatically, without user input.

See the [**Monthly Payroll Run Example**](/guides/business-owners/payroll#monthly-payroll-run-example) to understand the
level of complexity that Tight automates.

## Get Started

### Configure Check Integration

If you haven't already done so, you should create a developer account with Check at [checkhq.com](https://checkhq.com/).

Once you're logged into Check's Dashboard, navigate to the API Keys section to access your credentials.

<img alt="Check Config" />

### Securely share your Check keys

You should then copy your `Key ID`, this can be programmatically provided to
the [Configure Check API](/api-reference/integrations/configure-check).

For production deployment, repeat these steps using Check's Live mode toggle.


# Gusto
Source: https://docs.tight.com/integrations/payroll/gusto

Simplify the complex accounting that payroll necessitates with Tight

## Overview

Tight communicates directly with Gusto to automatically account for payroll directly in your users' books, including
automatically reconciling bank withdrawals against the payroll entries in real-time. The integration works for those
integrating with [Gusto Embedded Payroll](https://embedded.gusto.com/) and for end-users that
use [Gusto](https://gusto.com/) directly.

## Automated Reconciliation

In addition to a seamless UX, you and your users can rest assured knowing that the complex accounting that payroll
necessitates is automatically taken care of. When your user runs a payroll, the necessary accounting transactions are
automatically created in the user's General Ledger. Furthermore, when the bank withdrawals come in several days later,
the Tight API will automatically reconcile those with the payroll run, keeping the user's General Ledger and balance
sheets in sync, without any manual labor required from your user.

That reconciliation process, when done manually, can be very complex, as a single Gusto payroll run typically includes
at
least three bank withdrawals, all of which need to be mapped to different accounts. With the Tight API, this
reconciliation happens automatically, without user input.

See the [**Monthly Payroll Run Example**](/guides/business-owners/payroll#monthly-payroll-run-example) to understand the
level of complexity that Tight automates.

## Gusto (Retail) Payroll

### Configure Gusto Retail App

If you haven't already done so, you should [create a developer account with Gusto](https://dev.gusto.com/).

Once you're logged into Gusto's developer portal, you'll want
to [create an Organization](https://dev.gusto.com/organizations), which should be named after your *company*.

Once you have created your Organization, you will need to [create an Application](https://dev.gusto.com/applications),
which should be named after your *product*. First, you should create a product for the "demo" stage. When you create the
product, you will be prompted to enter a `Redirect URI`, which you should enter as
`https://redirect.sandbox.tight.com/integrations/gusto`:

<img alt="Gusto App Setup" />

Once you are done creating the Application, you will see the ability to copy your application's `Client ID` and
`Secret`:

<img alt="Gusto OAuthSettings" />

Once you are ready to go live in the "Production" environment, you will first need to submit a
[production application](https://docs.gusto.com/app-integrations/docs/security-review). Once approved, you can repeat
the above steps on the "Production" version of your application, and then use
`https://redirect.prod.tight.com/integrations/gusto` as the `Redirect URI`.

### Securely share your Gusto keys

You should then copy both the `Client ID` and `Secret` fields, these can be programmatically provided to
the [Configure Gusto API](/api-reference/integrations/configure-gusto).

### Connect your user's Gusto Retail accounts

1. For partners including Payroll connection from their own UX, use
   the [Start Gusto Flow API](/api-reference/integration-management/start-gusto-retail-flow) which wraps the entire OAuth
   2.0 flow such that you simply need to redirect your user to a single URL.
2. Tight's Embedded UI also provides UX from which users can kick off the Gusto connection flow, e.g.
   from the Payroll Dashboard

## Gusto Embedded Payroll

If your platform wants to embed payroll directly into your product, then Gusto Embedded Payroll may be a better solution
than Gusto's retail payroll product.

### Enable Gusto Embedded Connection

If you haven't embedded Gusto Embedded Payroll already,
an [expert from the Tight team](https://www.tight.com/#get-started) can introduce you to Gusto Embedded to get your team
registered quickly.

### Connect your user's Gusto Embedded Companies

To link your users' Gusto companies to those in Tight, simply hit
the [link Gusto API](/api-reference/integration-management/link-gusto).


# Salsa
Source: https://docs.tight.com/integrations/payroll/salsa

Simplify the complex accounting that payroll necessitates with Tight

## Overview

Tight communicates directly with Salsa to automatically account for payroll directly in your users' books, including
automatically reconciling bank withdrawals against the payroll entries in real-time. Salsa Express enables rapid payroll
deployment through embeddable UI components and straightforward APIs, allowing platforms to launch payroll within days.

## Automated Reconciliation

In addition to a seamless UX, you and your users can rest assured knowing that the complex accounting that payroll
necessitates is automatically taken care of. When your user runs a payroll, the necessary accounting transactions are
automatically created in the user's General Ledger. Furthermore, when the bank withdrawals come in several days later,
the Tight API will automatically reconcile those with the payroll run, keeping the user's General Ledger and balance
sheets in sync, without any manual labor required from your user.

That reconciliation process, when done manually, can be very complex, as a single Salsa payroll run typically includes at
least three bank withdrawals, all of which need to be mapped to different accounts. With the Tight API, this
reconciliation happens automatically, without user input.

See the [**Monthly Payroll Run Example**](/guides/business-owners/payroll#monthly-payroll-run-example) to understand the
level of complexity that Tight automates.

## Get Started

### Configure Salsa Integration

If you haven't already done so, you should create a developer account with Salsa at [salsa.dev](https://salsa.dev/).

Once you're logged into Salsa's developer portal, you can access your API credentials for both sandbox and production
environments.

### Securely share your Salsa keys

You should then copy your API credentials, these can be programmatically provided to
the [Configure Salsa API](/api-reference/integrations/configure-salsa).

For production deployment, repeat these steps using Salsa's production environment credentials.


# April
Source: https://docs.tight.com/integrations/tax/april

Enable your users to file their taxes in your platform

## Overview

Tight communicates directly with April to enable seamless tax filing directly within your platform. All financial data
flowing through the Tight API is automatically assembled into the formats needed for business owners to quickly and
easily file their taxes. Through this native integration with [April](https://www.getapril.com/), your users can access
a co-branded tax filing experience (Your Company + April) without any developer effort on your team's end.

## Automated Tax Data Assembly

In addition to a seamless UX, you and your users can rest assured knowing that complex tax preparation is automatically
taken care of. All data flowing through the Tight API (e.g. Plaid/bank transactions, Stripe invoicing/payment data,
etc.) is automatically categorized and assembled into the format needed to be ingested by April. That data is then
automatically sent to April, removing all integration work from your development team's workload.

## Getting Started

### Create an April developer account

If you haven't done so already, Tight can introduce you to April to get your team registered quickly. Alternatively, you can reach out directly to [sales@getapril.com](mailto:sales@getapril.com) to create a developer account.

### Securely share your April keys

Once April has created a developer account for you, your API credentials can be programmatically provided to
the [Configure April API](/api-reference/integrations/configure-april).

## Displaying the Tax Filing UX

You can quickly and easily
use [Tight's Income Tax Dashboard](/embeddable-ui/react/income-tax-dashboard), which includes all the
necessary UI for getting tax estimates and entering the DIY tax filing flow. This approach gets your product up and
running in minutes.

## Going Live in Production

The Tight API team will coordinate with the April team in order to perform QA testing, obtain access to production keys,
and ultimately go live in production.


# Column Tax
Source: https://docs.tight.com/integrations/tax/column-tax

Enable your users to file their taxes in your platform

## Overview

Tight communicates directly with Column Tax to enable seamless tax filing directly within your platform. All financial
data flowing through the Tight API is automatically assembled into the formats needed for business owners to quickly and
easily file their taxes. Through this native integration with [Column Tax](https://www.columntax.com/), your users can
access a co-branded tax filing experience (Your Company + Column Tax) without any developer effort on your team's end.

## Automated Tax Data Assembly

In addition to a seamless UX, you and your users can rest assured knowing that complex tax preparation is automatically
taken care of. All data flowing through the Tight API (e.g. Plaid/bank transactions, Stripe invoicing/payment data,
etc.) is automatically categorized and assembled into the format needed to be ingested by Column Tax. That data is then
automatically sent to Column Tax, removing all integration work from your development team's workload.

## Getting Started

### Create a Column Tax developer account

If you haven't done so already, Tight can introduce you to Column Tax to get your team registered quickly. Alternatively, you can reach out directly to [Column Tax](https://www.columntax.com/contact) to create a developer account and discuss partnership opportunities.

### Securely share your Column Tax keys

Once Column Tax has created a developer account for you, your API credentials can be programmatically provided to
the [Configure Column Tax API](/api-reference/integrations/configure-column-tax).

## Displaying the Tax Filing UX

You can quickly and easily use [Tight's Income Tax Dashboard](/embeddable-ui/react/income-tax-dashboard), which includes
all the necessary UI for getting tax estimates and entering the DIY tax filing flow. This approach gets your product up
and running in minutes.

## Going Live in Production

The Tight API team will coordinate with the Column Tax team in order to perform QA testing, obtain access to production
keys, and ultimately go live in production.


# Delete file
Source: https://docs.tight.com/api-reference/files/delete-file

https://dev.tight.com/v3/api-docs delete /v6/files/{id}
Delete a file for the given id



# Get file
Source: https://docs.tight.com/api-reference/files/get-file

https://dev.tight.com/v3/api-docs get /v6/files/{id}
Get a file for the given id



# Query files
Source: https://docs.tight.com/api-reference/files/query-files

https://dev.tight.com/v3/api-docs post /v6/files/query
Query files for the authenticated user



# Save files
Source: https://docs.tight.com/api-reference/files/save-files

https://dev.tight.com/v3/api-docs post /v6/files
Save new (or update existing) files



# Upload file
Source: https://docs.tight.com/api-reference/files/upload-file

https://dev.tight.com/v3/api-docs post /v6/files/upload
Upload a new file



# Upload file for entity
Source: https://docs.tight.com/api-reference/files/upload-file-for-entity

https://dev.tight.com/v3/api-docs post /v6/files/upload/{entityId}
Upload a file and associate it with an existing entity



# Delete GL account
Source: https://docs.tight.com/api-reference/gl-accounts/delete-gl-account

https://dev.tight.com/v3/api-docs delete /v6/accounting/glAccounts/{id}
Delete a GL account for the given id



# Get GL account
Source: https://docs.tight.com/api-reference/gl-accounts/get-gl-account

https://dev.tight.com/v3/api-docs get /v6/accounting/glAccounts/{id}
Get a GL account for the given id



# Save GL accounts
Source: https://docs.tight.com/api-reference/gl-accounts/save-gl-accounts

https://dev.tight.com/v3/api-docs post /v6/accounting/glAccounts
Save new (or update existing) GL accounts



# Query GL entries
Source: https://docs.tight.com/api-reference/gl-entries/query-gl-entries

https://dev.tight.com/v3/api-docs post /v6/accounting/glAccounts/{id}/generalLedger
Query GL entries for the authenticated user



# Delete integration
Source: https://docs.tight.com/api-reference/integration-management/delete-integration

https://dev.tight.com/v3/api-docs delete /v6/integrations/{id}
Delete an integration for the given id



# Finicity Transactions
Source: https://docs.tight.com/api-reference/integration-management/finicity-transactions

https://dev.tight.com/v3/api-docs post /v6/imports/finicity/transactions
Push new transactions directly from Finicity into the Tight API



# Get integration
Source: https://docs.tight.com/api-reference/integration-management/get-integration

https://dev.tight.com/v3/api-docs get /v6/integrations/{id}
Get an integration for the given id



# Link Adyen
Source: https://docs.tight.com/api-reference/integration-management/link-adyen

https://dev.tight.com/v3/api-docs post /v6/integrations/adyen/connection
Link a new (or update an existing) Adyen Connection



# Link April
Source: https://docs.tight.com/api-reference/integration-management/link-april

https://dev.tight.com/v3/api-docs post /v6/integrations/april/connection
Link a new (or update an existing) April Connection



# Link Check
Source: https://docs.tight.com/api-reference/integration-management/link-check

https://dev.tight.com/v3/api-docs post /v6/integrations/check/connection
Link a new (or update an existing) Check Connection



# Link ColumnTax
Source: https://docs.tight.com/api-reference/integration-management/link-columntax

https://dev.tight.com/v3/api-docs post /v6/integrations/columnTax/connection
Link a new (or update an existing) ColumnTax Connection



# Link Front
Source: https://docs.tight.com/api-reference/integration-management/link-front

https://dev.tight.com/v3/api-docs post /v6/integrations/front/connection
Link a new (or update an existing) Front Connection



# Link Gusto
Source: https://docs.tight.com/api-reference/integration-management/link-gusto

https://dev.tight.com/v3/api-docs post /v6/integrations/gusto/connection
Link a new (or update an existing) Gusto Connection



# Link Intercom
Source: https://docs.tight.com/api-reference/integration-management/link-intercom

https://dev.tight.com/v3/api-docs post /v6/integrations/intercom/connection
Link a new (or update an existing) Intercom Connection



# Link Mixpanel
Source: https://docs.tight.com/api-reference/integration-management/link-mixpanel

https://dev.tight.com/v3/api-docs post /v6/integrations/mixpanel/connection
Link a new (or update an existing) Mixpanel Connection



# Link Moov
Source: https://docs.tight.com/api-reference/integration-management/link-moov

https://dev.tight.com/v3/api-docs post /v6/integrations/moov/connection
Link a new (or update an existing) Moov Connection



# Link Plaid
Source: https://docs.tight.com/api-reference/integration-management/link-plaid

https://dev.tight.com/v3/api-docs post /v6/integrations/plaid/connection
Link a new (or update an existing) Plaid Connection



# Link Qualpay
Source: https://docs.tight.com/api-reference/integration-management/link-qualpay

https://dev.tight.com/v3/api-docs post /v6/integrations/qualpay/connection
Link a new (or update an existing) Qualpay Connection



# Link QuickBooks Online
Source: https://docs.tight.com/api-reference/integration-management/link-quickbooks-online

https://dev.tight.com/v3/api-docs post /v6/integrations/qbo/connection
Link a new (or update an existing) QuickBooks Online Connection



# Link Rutter
Source: https://docs.tight.com/api-reference/integration-management/link-rutter

https://dev.tight.com/v3/api-docs post /v6/integrations/rutter/connection
Link a new (or update an existing) Rutter Connection



# Link Salsa
Source: https://docs.tight.com/api-reference/integration-management/link-salsa

https://dev.tight.com/v3/api-docs post /v6/integrations/salsa/connection
Link a new (or update an existing) Salsa Connection



# Link Shopify
Source: https://docs.tight.com/api-reference/integration-management/link-shopify

https://dev.tight.com/v3/api-docs post /v6/integrations/shopify/connection
Link a new (or update an existing) Shopify Connection



# Link Square
Source: https://docs.tight.com/api-reference/integration-management/link-square

https://dev.tight.com/v3/api-docs post /v6/integrations/square/connection
Link a new (or update an existing) Square Connection



# Link Stripe
Source: https://docs.tight.com/api-reference/integration-management/link-stripe

https://dev.tight.com/v3/api-docs post /v6/integrations/stripe/connection
Link a new (or update an existing) Stripe Connection



# Link Unit
Source: https://docs.tight.com/api-reference/integration-management/link-unit

https://dev.tight.com/v3/api-docs post /v6/integrations/unit/connection
Link a new (or update an existing) Unit Connection



# Link Wave
Source: https://docs.tight.com/api-reference/integration-management/link-wave

https://dev.tight.com/v3/api-docs post /v6/integrations/wave/connection
Link a new (or update an existing) Wave Connection



# Link Xero
Source: https://docs.tight.com/api-reference/integration-management/link-xero

https://dev.tight.com/v3/api-docs post /v6/integrations/xero/connection
Link a new (or update an existing) Xero Connection



# MX Transactions
Source: https://docs.tight.com/api-reference/integration-management/mx-transactions

https://dev.tight.com/v3/api-docs post /v6/imports/mx/transactions
Push new transactions directly from MX Platform API into the Tight API



# Query Integrations
Source: https://docs.tight.com/api-reference/integration-management/query-integrations

https://dev.tight.com/v3/api-docs post /v6/integrations/query
Query integrations with pagination support



# Refresh integration
Source: https://docs.tight.com/api-reference/integration-management/refresh-integration

https://dev.tight.com/v3/api-docs post /v6/integrations/{id}/refresh
Refresh an integration for the given id



# Save integration
Source: https://docs.tight.com/api-reference/integration-management/save-integration

https://dev.tight.com/v3/api-docs post /v6/integrations/{id}
Save (or update an existing) integration



# Start Gusto Retail Flow
Source: https://docs.tight.com/api-reference/integration-management/start-gusto-retail-flow

https://dev.tight.com/v3/api-docs post /v6/integrations/gusto/authFlow
Start OAuth flow for Gusto



# Start QuickBooks Online Flow
Source: https://docs.tight.com/api-reference/integration-management/start-quickbooks-online-flow

https://dev.tight.com/v3/api-docs post /v6/integrations/qbo/authFlow
Initiate OAuth flow for QuickBooks Online



# Start Shopify Flow
Source: https://docs.tight.com/api-reference/integration-management/start-shopify-flow

https://dev.tight.com/v3/api-docs post /v6/integrations/shopify/authFlow
Start OAuth flow for Shopify



# Start Square Flow
Source: https://docs.tight.com/api-reference/integration-management/start-square-flow

https://dev.tight.com/v3/api-docs post /v6/integrations/square/authFlow
Start OAuth flow for Square



# Start Stripe Flow
Source: https://docs.tight.com/api-reference/integration-management/start-stripe-flow

https://dev.tight.com/v3/api-docs post /v6/integrations/stripe/authFlow
Initiate OAuth flow for Stripe



# Start Wave Flow
Source: https://docs.tight.com/api-reference/integration-management/start-wave-flow

https://dev.tight.com/v3/api-docs post /v6/integrations/wave/authFlow
Initiate OAuth flow for Wave



# Start Xero Flow
Source: https://docs.tight.com/api-reference/integration-management/start-xero-flow

https://dev.tight.com/v3/api-docs post /v6/integrations/xero/authFlow
Initiate OAuth flow for Xero



# Query journal entries
Source: https://docs.tight.com/api-reference/journal/query-journal-entries

https://dev.tight.com/v3/api-docs post /v6/reports/journal/query
Query the chronological list of journal entries with their debit/credit transactions for the authenticated user's company



# Delete car
Source: https://docs.tight.com/api-reference/mileage-cars/delete-car

https://dev.tight.com/v3/api-docs delete /v6/mileage/cars/{id}
Delete a car for the given id



# Get car
Source: https://docs.tight.com/api-reference/mileage-cars/get-car

https://dev.tight.com/v3/api-docs get /v6/mileage/cars/{id}
Get a car for the given id



# Query cars
Source: https://docs.tight.com/api-reference/mileage-cars/query-cars

https://dev.tight.com/v3/api-docs post /v6/mileage/cars/query
Query cars for the authenticated user



# Save cars
Source: https://docs.tight.com/api-reference/mileage-cars/save-cars

https://dev.tight.com/v3/api-docs post /v6/mileage/cars
Save new (or update existing) cars



# Delete location
Source: https://docs.tight.com/api-reference/mileage-locations/delete-location

https://dev.tight.com/v3/api-docs delete /v6/mileage/locations/{id}
Delete a favorite location for the given id



# Get location
Source: https://docs.tight.com/api-reference/mileage-locations/get-location

https://dev.tight.com/v3/api-docs get /v6/mileage/locations/{id}
Get a favorite location for the given id



# Query locations
Source: https://docs.tight.com/api-reference/mileage-locations/query-locations

https://dev.tight.com/v3/api-docs post /v6/mileage/locations/query
Query favorite locations for the authenticated user



# Save locations
Source: https://docs.tight.com/api-reference/mileage-locations/save-locations

https://dev.tight.com/v3/api-docs post /v6/mileage/locations
Save new (or update existing) favorite locations



# Delete route
Source: https://docs.tight.com/api-reference/mileage-routes/delete-route

https://dev.tight.com/v3/api-docs delete /v6/mileage/{mileageId}/route
Delete a route for the given mileage



# Get route
Source: https://docs.tight.com/api-reference/mileage-routes/get-route

https://dev.tight.com/v3/api-docs get /v6/mileage/{mileageId}/route
Get a route for the given mileage



# Save route
Source: https://docs.tight.com/api-reference/mileage-routes/save-route

https://dev.tight.com/v3/api-docs post /v6/mileage/{mileageId}/route
Save a route for the given mileage



# Get mileage setup
Source: https://docs.tight.com/api-reference/mileage-setup/get-mileage-setup

https://dev.tight.com/v3/api-docs get /v6/mileage/setup
Get the mileage setup for the authenticated user



# Save mileage setup
Source: https://docs.tight.com/api-reference/mileage-setup/save-mileage-setup

https://dev.tight.com/v3/api-docs post /v6/mileage/setup
Save (or update) the mileage setup for the authenticated user



# Delete mileage
Source: https://docs.tight.com/api-reference/mileage/delete-mileage

https://dev.tight.com/v3/api-docs delete /v6/mileage/{id}
Delete a mileage record for the given id



# Get mileage
Source: https://docs.tight.com/api-reference/mileage/get-mileage

https://dev.tight.com/v3/api-docs get /v6/mileage/{id}
Get a mileage record for the given id



# Query mileage
Source: https://docs.tight.com/api-reference/mileage/query-mileage

https://dev.tight.com/v3/api-docs post /v6/mileage/query
Query mileage records for the authenticated user



# Query mileage categories
Source: https://docs.tight.com/api-reference/mileage/query-mileage-categories

https://dev.tight.com/v3/api-docs post /v6/mileage/categories/query
Query mileage categories for the authenticated user



# Save mileage
Source: https://docs.tight.com/api-reference/mileage/save-mileage

https://dev.tight.com/v3/api-docs post /v6/mileage
Save new (or update existing) mileage records



# Get notification settings
Source: https://docs.tight.com/api-reference/notification-settings/get-notification-settings

https://dev.tight.com/v3/api-docs get /v6/notifications/settings
Get the authenticated user's notification preferences



# Save notification settings
Source: https://docs.tight.com/api-reference/notification-settings/save-notification-settings

https://dev.tight.com/v3/api-docs post /v6/notifications/settings
Save the authenticated user's notification preferences



# Aged Accounts Payable
Source: https://docs.tight.com/api-reference/reports/aged-accounts-payable

https://dev.tight.com/v3/api-docs post /v6/reports/agedAccountsPayable
Generate an Aged Accounts Payable Report



# Aged Accounts Receivable
Source: https://docs.tight.com/api-reference/reports/aged-accounts-receivable

https://dev.tight.com/v3/api-docs post /v6/reports/agedAccountsReceivable
Generate an Aged Accounts Receivable Report



# Balance Sheet
Source: https://docs.tight.com/api-reference/reports/balance-sheet

https://dev.tight.com/v3/api-docs post /v6/reports/balanceSheet
Generate a Balance Sheet



# Cash Flow Statement
Source: https://docs.tight.com/api-reference/reports/cash-flow-statement

https://dev.tight.com/v3/api-docs post /v6/reports/cashFlowStatement
Generate a Cash Flow Statement



# Chart of Accounts
Source: https://docs.tight.com/api-reference/reports/chart-of-accounts

https://dev.tight.com/v3/api-docs post /v6/reports/chartOfAccounts
Generate a Chart of Accounts Report



# Expense Report
Source: https://docs.tight.com/api-reference/reports/expense-report

https://dev.tight.com/v3/api-docs post /v6/reports/expenses
Generate an Expense Report



# Form 1065
Source: https://docs.tight.com/api-reference/reports/form-1065

https://dev.tight.com/v3/api-docs post /v6/reports/form1065
Generate a Form 1065 tax form



# Form 1120
Source: https://docs.tight.com/api-reference/reports/form-1120

https://dev.tight.com/v3/api-docs post /v6/reports/form1120
Generate a Form 1120 tax form



# Form 1120-S
Source: https://docs.tight.com/api-reference/reports/form-1120-s

https://dev.tight.com/v3/api-docs post /v6/reports/form1120S
Generate a Form 1120-S tax form



# Profit and Loss
Source: https://docs.tight.com/api-reference/reports/profit-and-loss

https://dev.tight.com/v3/api-docs post /v6/reports/profitAndLoss
Generate a Profit and Loss Statement



# Revenue Report
Source: https://docs.tight.com/api-reference/reports/revenue-report

https://dev.tight.com/v3/api-docs post /v6/reports/revenue
Generate a Revenue Report



# Schedule C
Source: https://docs.tight.com/api-reference/reports/schedule-c

https://dev.tight.com/v3/api-docs post /v6/reports/scheduleC
Generate a Schedule C tax form



# Schedule E
Source: https://docs.tight.com/api-reference/reports/schedule-e

https://dev.tight.com/v3/api-docs post /v6/reports/scheduleE
Generate a Schedule E tax form



# T2125
Source: https://docs.tight.com/api-reference/reports/t2125

https://dev.tight.com/v3/api-docs post /v6/reports/t2125
Generate a T2125 tax form



# Trial Balance
Source: https://docs.tight.com/api-reference/reports/trial-balance

https://dev.tight.com/v3/api-docs post /v6/reports/trialBalance
Generate a Trial Balance Report



# Get tax estimates
Source: https://docs.tight.com/api-reference/tax-estimates/get-tax-estimates

https://dev.tight.com/v3/api-docs post /v6/taxes/taxEstimates
Get a summary of a user's tax obligations; also useful for displaying a real-time P&L



# Get tax profile
Source: https://docs.tight.com/api-reference/tax-profile/get-tax-profile

https://dev.tight.com/v3/api-docs get /v6/taxes/setup
Get the authenticated user's tax profile configuration



# Save tax profile
Source: https://docs.tight.com/api-reference/tax-profile/save-tax-profile

https://dev.tight.com/v3/api-docs post /v6/taxes/setup
Save the authenticated user's tax profile configuration



# Delete time
Source: https://docs.tight.com/api-reference/time-tracking--times/delete-time

https://dev.tight.com/v3/api-docs delete /v6/timeTracking/times/{id}
Delete a time tracking entry for the given id



# Get time
Source: https://docs.tight.com/api-reference/time-tracking--times/get-time

https://dev.tight.com/v3/api-docs get /v6/timeTracking/times/{id}
Get a time tracking entry for the given id



# Query times
Source: https://docs.tight.com/api-reference/time-tracking--times/query-times

https://dev.tight.com/v3/api-docs post /v6/timeTracking/times/query
Query time tracking entries for the authenticated user



# Save times
Source: https://docs.tight.com/api-reference/time-tracking--times/save-times

https://dev.tight.com/v3/api-docs post /v6/timeTracking/times
Save new (or update existing) time tracking entries



# Get task
Source: https://docs.tight.com/api-reference/time-tracking-tasks/get-task

https://dev.tight.com/v3/api-docs get /v6/timeTracking/tasks/{id}
Get a time tracking task for the given id



# Query tasks
Source: https://docs.tight.com/api-reference/time-tracking-tasks/query-tasks

https://dev.tight.com/v3/api-docs post /v6/timeTracking/tasks/query
Query time tracking tasks for the authenticated user



# Save tasks
Source: https://docs.tight.com/api-reference/time-tracking-tasks/save-tasks

https://dev.tight.com/v3/api-docs post /v6/timeTracking/tasks
Save new (or update existing) time tracking tasks



# Delete vendor
Source: https://docs.tight.com/api-reference/vendors/delete-vendor

https://dev.tight.com/v3/api-docs delete /v6/vendors/{id}
Delete a vendor for the given id



# Get vendor
Source: https://docs.tight.com/api-reference/vendors/get-vendor

https://dev.tight.com/v3/api-docs get /v6/vendors/{id}
Get a vendor for the given id



# Query vendors
Source: https://docs.tight.com/api-reference/vendors/query-vendors

https://dev.tight.com/v3/api-docs post /v6/vendors/query
Query vendors for the authenticated user



# Save vendors
Source: https://docs.tight.com/api-reference/vendors/save-vendors

https://dev.tight.com/v3/api-docs post /v6/vendors
Save new (or update existing) vendors



# Get Agentic Accountant Settings
Source: https://docs.tight.com/api-reference/agentic-accounting-settings/get-agentic-accountant-settings

https://dev.tight.com/v3/api-docs get /v6/templates/agent/settings
Get the partner's agentic accounting configuration



# Save Agentic Accountant Settings
Source: https://docs.tight.com/api-reference/agentic-accounting-settings/save-agentic-accountant-settings

https://dev.tight.com/v3/api-docs post /v6/templates/agent/settings
Save the partner's agentic accounting configuration



# Delete transaction
Source: https://docs.tight.com/api-reference/bank-transactions/delete-transaction

https://dev.tight.com/v3/api-docs delete /v6/banks/transactions/{id}
Delete an existing transaction



# Get transaction
Source: https://docs.tight.com/api-reference/bank-transactions/get-transaction

https://dev.tight.com/v3/api-docs get /v6/banks/transactions/{id}
Get a transaction for the given id



# Query transaction summary
Source: https://docs.tight.com/api-reference/bank-transactions/query-transaction-summary

https://dev.tight.com/v3/api-docs post /v6/banks/transactions/query/summary
Query transaction summary for the authenticated user



# Query transactions
Source: https://docs.tight.com/api-reference/bank-transactions/query-transactions

https://dev.tight.com/v3/api-docs post /v6/banks/transactions/query
Query transactions for the authenticated user



# Save transactions
Source: https://docs.tight.com/api-reference/bank-transactions/save-transactions

https://dev.tight.com/v3/api-docs post /v6/banks/transactions
Save a new (or update an existing) set of transactions



# Delete bill
Source: https://docs.tight.com/api-reference/bills/delete-bill

https://dev.tight.com/v3/api-docs delete /v6/bills/{id}
Delete a bill for the given id



# Get bill
Source: https://docs.tight.com/api-reference/bills/get-bill

https://dev.tight.com/v3/api-docs get /v6/bills/{id}
Get a bill for the given id



# Query bills
Source: https://docs.tight.com/api-reference/bills/query-bills

https://dev.tight.com/v3/api-docs post /v6/bills/query
Query bills for the authenticated user



# Save bills
Source: https://docs.tight.com/api-reference/bills/save-bills

https://dev.tight.com/v3/api-docs post /v6/bills
Save new (or update existing) bills



# Get categories
Source: https://docs.tight.com/api-reference/categories/get-categories

https://dev.tight.com/v3/api-docs get /v6/categories
Get all categories for the authenticated user, grouped by type



# Get category
Source: https://docs.tight.com/api-reference/categories/get-category

https://dev.tight.com/v3/api-docs get /v6/categories/{id}
Get a category for the given id



# List global GL accounts
Source: https://docs.tight.com/api-reference/global/list-global-gl-accounts

https://dev.tight.com/v3/api-docs get /v6/global/glAccounts
Returns the static list of all Global GL accounts.



# Configure identity provider
Source: https://docs.tight.com/api-reference/identity-provider-configuration/configure-identity-provider

https://dev.tight.com/v3/api-docs post /v6/config/integrations/identityProvider
Configure the identity provider integration for the partner



# Configure Adyen
Source: https://docs.tight.com/api-reference/integrations/configure-adyen

https://dev.tight.com/v3/api-docs post /v6/config/integrations/adyen
Configure Adyen integration credentials



# Configure April
Source: https://docs.tight.com/api-reference/integrations/configure-april

https://dev.tight.com/v3/api-docs post /v6/config/integrations/april
Configure April integration credentials



# Configure Check
Source: https://docs.tight.com/api-reference/integrations/configure-check

https://dev.tight.com/v3/api-docs post /v6/config/integrations/check
Configure Check integration credentials



# Configure Column Tax
Source: https://docs.tight.com/api-reference/integrations/configure-column-tax

https://dev.tight.com/v3/api-docs post /v6/config/integrations/columnTax
Configure Column Tax integration credentials



# Configure Front
Source: https://docs.tight.com/api-reference/integrations/configure-front

https://dev.tight.com/v3/api-docs post /v6/config/integrations/front
Configure Front integration credentials



# Configure Gusto
Source: https://docs.tight.com/api-reference/integrations/configure-gusto

https://dev.tight.com/v3/api-docs post /v6/config/integrations/gusto
Configure Gusto integration credentials



# Configure Intercom
Source: https://docs.tight.com/api-reference/integrations/configure-intercom

https://dev.tight.com/v3/api-docs post /v6/config/integrations/intercom
Configure Intercom integration credentials



# Configure Mixpanel
Source: https://docs.tight.com/api-reference/integrations/configure-mixpanel

https://dev.tight.com/v3/api-docs post /v6/config/integrations/mixpanel
Configure Mixpanel integration credentials



# Configure Moov
Source: https://docs.tight.com/api-reference/integrations/configure-moov

https://dev.tight.com/v3/api-docs post /v6/config/integrations/moov
Configure Moov integration credentials



# Configure Plaid
Source: https://docs.tight.com/api-reference/integrations/configure-plaid

https://dev.tight.com/v3/api-docs post /v6/config/integrations/plaid
Configure Plaid integration credentials



# Configure Qualpay
Source: https://docs.tight.com/api-reference/integrations/configure-qualpay

https://dev.tight.com/v3/api-docs post /v6/config/integrations/qualpay
Configure Qualpay integration credentials



# Configure Rutter
Source: https://docs.tight.com/api-reference/integrations/configure-rutter

https://dev.tight.com/v3/api-docs post /v6/config/integrations/rutter
Configure Rutter integration credentials



# Configure Salsa
Source: https://docs.tight.com/api-reference/integrations/configure-salsa

https://dev.tight.com/v3/api-docs post /v6/config/integrations/salsa
Configure Salsa integration credentials



# Configure Shopify
Source: https://docs.tight.com/api-reference/integrations/configure-shopify

https://dev.tight.com/v3/api-docs post /v6/config/integrations/shopify
Configure Shopify integration credentials



# Configure Square
Source: https://docs.tight.com/api-reference/integrations/configure-square

https://dev.tight.com/v3/api-docs post /v6/config/integrations/square
Configure Square integration credentials



# Configure Stripe
Source: https://docs.tight.com/api-reference/integrations/configure-stripe

https://dev.tight.com/v3/api-docs post /v6/config/integrations/stripe
Configure Stripe integration credentials



# Configure Twilio
Source: https://docs.tight.com/api-reference/integrations/configure-twilio

https://dev.tight.com/v3/api-docs post /v6/config/integrations/twilio
Configure Twilio integration credentials



# Configure Unit
Source: https://docs.tight.com/api-reference/integrations/configure-unit

https://dev.tight.com/v3/api-docs post /v6/config/integrations/unit
Configure Unit integration credentials



# Delete invoice
Source: https://docs.tight.com/api-reference/invoicing--invoices/delete-invoice

https://dev.tight.com/v3/api-docs delete /v6/invoicing/invoices/{id}
Delete an invoice for the given id



# Get invoice
Source: https://docs.tight.com/api-reference/invoicing--invoices/get-invoice

https://dev.tight.com/v3/api-docs get /v6/invoicing/invoices/{id}
Get an invoice for the given id



# Query invoices
Source: https://docs.tight.com/api-reference/invoicing--invoices/query-invoices

https://dev.tight.com/v3/api-docs post /v6/invoicing/invoices/query
Query invoices for the authenticated user



# Refund invoice
Source: https://docs.tight.com/api-reference/invoicing--invoices/refund-invoice

https://dev.tight.com/v3/api-docs post /v6/invoicing/invoices/{id}/refund
Refund an invoice for the given id



# Save invoices
Source: https://docs.tight.com/api-reference/invoicing--invoices/save-invoices

https://dev.tight.com/v3/api-docs post /v6/invoicing/invoices
Save new (or update existing) invoices



# Send invoice
Source: https://docs.tight.com/api-reference/invoicing--invoices/send-invoice

https://dev.tight.com/v3/api-docs post /v6/invoicing/invoices/{id}/send
Send an invoice, quote, or reminder for the given id



# Delete invoice item template
Source: https://docs.tight.com/api-reference/invoicing--item-templates/delete-invoice-item-template

https://dev.tight.com/v3/api-docs delete /v6/invoicing/itemTemplates/{id}
Delete an invoice item template for the given id



# Get invoice item template
Source: https://docs.tight.com/api-reference/invoicing--item-templates/get-invoice-item-template

https://dev.tight.com/v3/api-docs get /v6/invoicing/itemTemplates/{id}
Get an invoice item template for the given id



# Query invoice item templates
Source: https://docs.tight.com/api-reference/invoicing--item-templates/query-invoice-item-templates

https://dev.tight.com/v3/api-docs post /v6/invoicing/itemTemplates/query
Query invoice item templates for the authenticated user



# Save invoice item templates
Source: https://docs.tight.com/api-reference/invoicing--item-templates/save-invoice-item-templates

https://dev.tight.com/v3/api-docs post /v6/invoicing/itemTemplates
Save new (or update existing) invoice item templates



# Get invoicing setup
Source: https://docs.tight.com/api-reference/invoicing--setup/get-invoicing-setup

https://dev.tight.com/v3/api-docs get /v6/invoicing/setup
Get invoicing setup configuration for the authenticated user



# Save invoicing setup
Source: https://docs.tight.com/api-reference/invoicing--setup/save-invoicing-setup

https://dev.tight.com/v3/api-docs post /v6/invoicing/setup
Save invoicing setup configuration for the authenticated user



# Delete manual journal entry
Source: https://docs.tight.com/api-reference/manual-journal-entries/delete-manual-journal-entry

https://dev.tight.com/v3/api-docs delete /v6/accounting/manualJournalEntries/{id}
Delete a manual journal entry for the given id



# Get manual journal entry
Source: https://docs.tight.com/api-reference/manual-journal-entries/get-manual-journal-entry

https://dev.tight.com/v3/api-docs get /v6/accounting/manualJournalEntries/{id}
Get a manual journal entry for the given id



# Query manual journal entries
Source: https://docs.tight.com/api-reference/manual-journal-entries/query-manual-journal-entries

https://dev.tight.com/v3/api-docs post /v6/accounting/manualJournalEntries/query
Query manual journal entries for the authenticated user



# Save manual journal entries
Source: https://docs.tight.com/api-reference/manual-journal-entries/save-manual-journal-entries

https://dev.tight.com/v3/api-docs post /v6/accounting/manualJournalEntries
Save new (or update existing) manual journal entries



# Delete payment
Source: https://docs.tight.com/api-reference/payments/delete-payment

https://dev.tight.com/v3/api-docs delete /v6/payments/{id}
Delete a payment for the given id



# Get payment
Source: https://docs.tight.com/api-reference/payments/get-payment

https://dev.tight.com/v3/api-docs get /v6/payments/{id}
Get a payment for the given id



# Query payments
Source: https://docs.tight.com/api-reference/payments/query-payments

https://dev.tight.com/v3/api-docs post /v6/payments/query
Query payments for the authenticated user



# Save payments
Source: https://docs.tight.com/api-reference/payments/save-payments

https://dev.tight.com/v3/api-docs post /v6/payments
Save new (or update existing) payments



# Delete payroll
Source: https://docs.tight.com/api-reference/payroll/delete-payroll

https://dev.tight.com/v3/api-docs delete /v6/payroll/{id}
Delete a payroll entry for the given id



# Get payroll
Source: https://docs.tight.com/api-reference/payroll/get-payroll

https://dev.tight.com/v3/api-docs get /v6/payroll/{id}
Get a payroll entry for the given id



# Query payroll
Source: https://docs.tight.com/api-reference/payroll/query-payroll

https://dev.tight.com/v3/api-docs post /v6/payroll/query
Query payroll for the authenticated user



# Save payroll
Source: https://docs.tight.com/api-reference/payroll/save-payroll

https://dev.tight.com/v3/api-docs post /v6/payroll
Save new (or update existing) payroll



# Delete business type
Source: https://docs.tight.com/api-reference/templates/delete-business-type

https://dev.tight.com/v3/api-docs delete /v6/templates/businessTypes/{id}
Delete a business type



# Delete dimension
Source: https://docs.tight.com/api-reference/templates/delete-dimension

https://dev.tight.com/v3/api-docs delete /v6/templates/dimensions/{id}
Delete a dimension. Cannot delete dimensions with associated dimension values or children.



# Delete template rule
Source: https://docs.tight.com/api-reference/templates/delete-template-rule

https://dev.tight.com/v3/api-docs delete /v6/templates/rules/{id}
Delete a template rule for the given id



# Get business types
Source: https://docs.tight.com/api-reference/templates/get-business-types

https://dev.tight.com/v3/api-docs get /v6/templates/businessTypes
These are used to configure the various segments of your user base. Expense categories, chart of accounts, rules, and future learning algorithms smartly take your business types into account.



# Get chart of accounts templates
Source: https://docs.tight.com/api-reference/templates/get-chart-of-accounts-templates

https://dev.tight.com/v3/api-docs get /v6/templates/chartOfAccounts
These are used to configure the default chart of accounts for the <a href="/api-reference/templates/get-business-types">various segments of your user base</a>.



# Get template rule
Source: https://docs.tight.com/api-reference/templates/get-template-rule

https://dev.tight.com/v3/api-docs get /v6/templates/rules/{id}
Get a template rule for the given id



# Query dimensions
Source: https://docs.tight.com/api-reference/templates/query-dimensions

https://dev.tight.com/v3/api-docs post /v6/templates/dimensions/query
Query dimensions for the authenticated user. Use these to configure any dimensions that your users need to track against. These are what your users will see and can assign transactions to (e.g., Location, Job, Department, etc.). Dimensions can be hierarchical (e.g., Region -> Location -> Building).



# Query template rules
Source: https://docs.tight.com/api-reference/templates/query-template-rules

https://dev.tight.com/v3/api-docs post /v6/templates/rules/query
Query template rules for the authenticated user



# Save business types
Source: https://docs.tight.com/api-reference/templates/save-business-types

https://dev.tight.com/v3/api-docs post /v6/templates/businessTypes
Save a new (or update an existing) set of business types



# Save chart of accounts template
Source: https://docs.tight.com/api-reference/templates/save-chart-of-accounts-template

https://dev.tight.com/v3/api-docs post /v6/templates/chartOfAccounts
Save a new (or update an existing) chart of accounts template



# Save Chart of Accounts template mappings
Source: https://docs.tight.com/api-reference/templates/save-chart-of-accounts-template-mappings

https://dev.tight.com/v3/api-docs post /v6/templates/chartOfAccounts/{templateId}/mapping
Map GlobalGlAccounts to template GL accounts for transaction categorization.



# Save dimensions
Source: https://docs.tight.com/api-reference/templates/save-dimensions

https://dev.tight.com/v3/api-docs post /v6/templates/dimensions
Save a new (or update an existing) set of dimensions



# Save template rules
Source: https://docs.tight.com/api-reference/templates/save-template-rules

https://dev.tight.com/v3/api-docs post /v6/templates/rules
Save new (or update existing) template rules



# Delete task
Source: https://docs.tight.com/api-reference/time-tracking-tasks/delete-task

https://dev.tight.com/v3/api-docs delete /v6/timeTracking/tasks/{id}
Delete a time tracking task for the given id



# Delete transaction rule
Source: https://docs.tight.com/api-reference/transaction-rules/delete-transaction-rule

https://dev.tight.com/v3/api-docs delete /v6/banks/transactions/rules/{id}
Delete a transaction rule for the given id



# Get transaction rule
Source: https://docs.tight.com/api-reference/transaction-rules/get-transaction-rule

https://dev.tight.com/v3/api-docs get /v6/banks/transactions/rules/{id}
Get a transaction rule for the given id



# Query transaction rules
Source: https://docs.tight.com/api-reference/transaction-rules/query-transaction-rules

https://dev.tight.com/v3/api-docs post /v6/banks/transactions/rules/query
Query transaction rules for the authenticated user



# Save transaction rules
Source: https://docs.tight.com/api-reference/transaction-rules/save-transaction-rules

https://dev.tight.com/v3/api-docs post /v6/banks/transactions/rules
Save new (or update existing) transaction rules



# Playground
Source: https://docs.tight.com/playground

Explore the Tight Embedded End-to-End UX in the Playground

<PlaygroundIframe />


# Releases
Source: https://docs.tight.com/roadmap/releases



<Update label="September 29, 2026" description="v6.10.9">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * Agents can now tailor a business's chart of accounts via MCP by adding and editing its
    [General Ledger accounts](/api-reference/gl-accounts/save-gl-accounts).

  ## **Existing v5 Features Upgraded to v6**

  ### Bank Transactions

  * Searching or filtering [bank transactions](/api-reference/bank-transactions/query-transactions) now returns a split
    transaction when any of its line items match.

  ### Embedded UI

  * You can now restyle the empty-state call-to-action buttons in the v6 embedded UI with new
    [design tokens](/embeddable-ui/react/reference/design-tokens).

  ## **Fixes**

  ### Bank Transactions

  * Users can now pick accounts imported from another accounting platform, such as QuickBooks Online, when merging
    duplicates into a linked account in [Banks & Integrations](/embeddable-ui/react/banks-and-integrations).
  * [Bank statements](/api-reference/bank-statements/query-bank-statements) now download soon after Plaid finishes
    refreshing them, rather than waiting behind a backlog of transaction updates.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="September 15, 2026" description="v6.10.8">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * Agents can now create and manage [payroll](/api-reference/payroll/query-payroll) entries via MCP.

  ## **Existing v5 Features Upgraded to v6**

  ### Payroll

  * When a [bank transaction](/api-reference/bank-transactions/query-transactions) is linked to a payroll, expanding
    the payroll now returns the individual line items the transaction is linked to.

  ### Bank Transactions

  * Tax payments now appear as an expense category in the
    [transaction form](/embeddable-ui/react/bank-transactions/transaction-form), instead of a separate type.

  ## **Fixes**

  ### Reports

  * Drilling from Net Income on the [Cash Flow Statement](/embeddable-ui/react/financial-statements/cash-flow-statement)
    into the [Profit & Loss report](/embeddable-ui/react/financial-statements/profit-loss-report) now carries the
    report's customer and dimension filters and grouping.
  * A [Balance Sheet](/api-reference/reports/balance-sheet) now exports to CSV successfully when an account's balance
    is above \$21 million.

  ### Integrations

  * QuickBooks: [imports](/embeddable-ui/react/imports/quickbooks-online-import) now record bill payments made by
    credit card as bill payments rather than manual journal entries.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="September 1, 2026" description="v6.10.7">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * Agents can now create and manage [categorization rules](/api-reference/transaction-rules/save-transaction-rules)
    via MCP, including [partner-level template rules](/api-reference/templates/save-template-rules) that apply across
    every company you manage.

  ## **Existing v5 Features Upgraded to v6**

  ### Payroll

  * Payroll is now available in v6, with [save](/api-reference/payroll/save-payroll),
    [query](/api-reference/payroll/query-payroll), and [get](/api-reference/payroll/get-payroll) operations covering a
    payroll and its line items, such as net pay, employer tax, and employee benefit.

  ### Journal

  * The [`Journal`](/embeddable-ui/react/accounting/journal) component is now available in the v6 embedded UI, where end
    users can review journal entries with their debits and credits.
  * An edit to one occurrence of a recurring
    [manual journal entry](/api-reference/manual-journal-entries/save-manual-journal-entries) can now be applied to
    every later occurrence at once with the new `SINGLE_RECURRENCE_AND_ALL_FUTURE` update type.

  ### General Ledger

  * [General Ledger entries](/api-reference/gl-entries/query-gl-entries) can now be filtered by customer, with the
    beginning and running balances recalculated for the filtered set.

  ### Bank Transactions

  * A [payment](/api-reference/payments/query-payments) or
    [bank transaction](/api-reference/bank-transactions/query-transactions) query can now expand its linked invoice
    with the `apiSourceId` you assigned, so you can match it to your own invoice record without a second lookup.

  ### Embedded UI

  * The [`FinancialOverview`](/embeddable-ui/react/financial-overview) dashboard now opens on the previous month by
    default rather than the current one.

  ## **Fixes**

  ### Reports

  * Specifying `accountingMethod: ACCRUAL` on a [Balance Sheet](/api-reference/reports/balance-sheet) report request
    now returns the correct value for Current Income.
  * Drilling from a report into the [General Ledger](/embeddable-ui/react/accounting/general-ledger) now carries the
    report's dimension and customer filters, and returning by breadcrumb restores the report as it was left.

  ### Bank Transactions

  * A money-in [bank transaction](/api-reference/bank-transactions/query-transactions) categorized to a `SUSPENSE`
    General Ledger account now returns a `type` of `REVENUE` instead of `EXPENSE`.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="August 18, 2026" description="v6.10.6">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * Agents can now read and write[ manual journal entries](/api-reference/manual-journal-entries/save-manual-journal-entries) via MCP.
  * New MCP tooling for building and managing [chart of accounts templates](/api-reference/templates/save-chart-of-accounts-template).
  * The new `generate_one_time_link` MCP tool returns a single-use login link, so an agent can drop a user straight into
    your [Ready-to-Launch](/guides/launch-paths/ready-to-launch) experience.

  ### Authentication

  * Partners using [Ready-to-Launch](/guides/launch-paths/ready-to-launch) can now generate
    [one-time login links](/api-reference/auth/generate-one-time-link) for any of their users, including bookkeepers
    accessing a specific business directly.

  ## **Existing v5 Features Upgraded to v6**

  ### Bank Reconciliation

  * [Bank account queries](/api-reference/bank-accounts/query-bank-accounts) now return each account's reconciliation
    state, including the end date of the most recent completed reconciliation.

  ### Journal

  * [Journal entries](/api-reference/journal/query-journal-entries) now include a `typeDisplayName` alongside the raw
    `type`.

  ## **Fixes**

  ### Bank Transactions

  * [Saving a transaction](/api-reference/bank-transactions/save-transactions) now rejects an `originalCurrency` for
    which no exchange rate is published, such as `MRU` or `MGA`, with a validation error on that field.
  * Creating a [payment](/api-reference/payments/save-payments) with an `apiSourceId` already used on the same bank
    account is now rejected as a duplicate.
  * Choosing "Bank transfer" on a transaction in the embedded
    [transaction form](/embeddable-ui/react/bank-transactions/transaction-form) now returns the matching transactions to
    link against, including transfers already recorded on another account regardless of date.

  ### General Ledger

  * Opening a payment-processor entry in the
    [`GeneralLedger`](/embeddable-ui/react/accounting/general-ledger) component now fires
    `OPEN_PROCESSOR_TRANSACTION_FORM` carrying the payment record, so a listener typed only to a bank transaction needs
    to widen to accept both shapes.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="August 4, 2026" description="v6.10.3">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * New MCP tools for [Bank Statements](/api-reference/bank-statements/query-bank-statements).

  ### Embedded UI

  * Addition of new [design tokens](/embeddable-ui/react/reference/design-tokens) for improved customizability on the
    navigation panel, menu controls, and expense and income overviews.

  ### Bank Transactions

  * Incoming bank transactions now automatically match to processor transactions created through the API, not only
    to processor payouts Tight ingested as part of its [payment processor integrations](/integrations/payment-processing/stripe).

  ## **Existing v5 Features Upgraded to v6**

  ### Embedded UI

  * Transaction form events can now be received through dedicated `bankTransactionForm` and `processorTransactionForm`
    listeners.

  ### Chart of Accounts

  * The [Chart of Accounts](/embeddable-ui/react/accounting/chart-of-accounts) component is now available in the v6
    embedded UI, where end users can manage accounts and drill into the General Ledger from an individual account.

  ### Journal

  * The journal is now available in v6 through `POST /v6/reports/journal/query`, returning every journal entry in date
    order with its debit and credit lines.
  * [Manual journal entries](/api-reference/manual-journal-entries/save-manual-journal-entries) are now live in v6.

  ### Reports

  * [Profit & Loss](/api-reference/reports/profit-and-loss), [Balance Sheet](/api-reference/reports/balance-sheet), and
    [Cash Flow Statement](/api-reference/reports/cash-flow-statement) exports/emails are now available in the v6 embedded UI.
  * The [Trial Balance report](/embeddable-ui/react/financial-statements/trial-balance-report) is now available in the v6
    [`ReportDashboard`](/embeddable-ui/react/financial-statements/report-dashboard) component.

  ### General Ledger

  * The [`GeneralLedger`](/embeddable-ui/react/accounting/general-ledger) component is now available in v6. Use it to search
    ledger entries and recategorize transactions inline.
  * Select any amount in the Balance Sheet and Cash Flow Statement report to drill down to the
    [`GeneralLedger`](/embeddable-ui/react/accounting/general-ledger) component, filtered to the account and date range of
    the selected amount.

  ## **Fixes**

  ### Companies

  * [Company queries](/api-reference/company-management/query-companies) now return a `status` of `ACTIVE` or `INACTIVE`
    on every company.

  ### Bank Transactions

  * Saving a transaction as `TRANSFER_IN` or `TRANSFER_OUT` while removing all of its line items now succeeds instead of
    failing with "Bank Transfers cannot have children".
  * Updating or deleting a payment nested under a parent bank transaction no longer clears its `bankTransaction` link.
  * [Saving a split transaction](/api-reference/bank-transactions/save-transactions) now requires every child to be
    itemized by the same fields, so mixing children with and without a `customerId` or `dimensionValueIds` is rejected.
  * The bank transaction form in the embedded UI now includes an editable Review Status field.
  * [Deleting a payment](/api-reference/payments/delete-payment), or changing its amount or status, is now rejected when
    that payment is matched to a bank transaction.

  ### Reports

  * Suspense account balances, such as "Ask My Client", now appear under Other Expenses on the v6
    [Profit & Loss](/api-reference/reports/profit-and-loss) report and reduce net income, matching v5.

  ### Embedded UI

  * Selecting a status other than Active on the transaction, income, and expense dashboards now filters the list, and
    Active appears as a visible default filter chip rather than being applied invisibly.
  * Opening a transaction from a General Ledger row now fires `OPEN_BANK_TRANSACTION_FORM` with the full transaction in
    `data` instead of `null`.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="July 21, 2026" description="v6.10.0">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * New MCP tools for creating mileage and related entities, dimension values, time tracking, tax profile, transactions in
    bulk, invoices, and payments.

  ### Integrations

  * Integration credential configuration is now live in v6: save credentials for
    [Plaid](/api-reference/integrations/configure-plaid), [Stripe](/api-reference/integrations/configure-stripe), and
    seven other providers directly through the API.
  * Plaid: a new `statementsEnabled` flag on [Plaid credentials](/api-reference/integrations/configure-plaid) turns on
    bank statement syncing; the Statements product must first be enabled for your `client_id` in the Plaid Dashboard.
  * Plaid: Added ability to automatically estimate beginning balances on all synced accounts. Reach out to the Tight team
    to enable this feature.

  ## **Existing v5 Features Upgraded to v6**

  ### General Ledger

  * The [query](/api-reference/gl-accounts/query-gl-accounts) and [save](/api-reference/gl-accounts/save-gl-accounts)
    General Ledger account endpoints are now live in v6, so you can list a company's accounts and create, update, or
    deactivate them.
  * The [General Ledger entries query](/api-reference/gl-entries/query-gl-entries) accepts a new
    `includeBeginningBalance` flag to request a beginning balance for non-balance-sheet accounts; balance sheet accounts
    include one automatically.

  ## **Fixes**

  ### Bank Transactions

  * Inserting a transaction line item with an `apiItemId` that already exists in the company now returns a validation
    error instead of a generic exception.
  * Line items on a split transaction can now be assigned personal (`EQUITY`-type) General Ledger accounts, which were
    previously rejected as transfer accounts.
  * Updating a payment transaction that came no longer clears its `apiProcessorPayoutId`; the transaction stays linked to
    its payout.

  ### Vendors

  * Syncing bank transactions no longer creates duplicate vendors when a matching vendor already exists, even one that is
    inactive or was removed; the existing vendor is reused and is reactivated when tagged to an expense transaction.

  ### Integrations

  * Adyen: outgoing internal transfers on an Adyen balance platform account are now recorded as expense transactions.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="July 7, 2026" description="v6.9.0">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * The [`query_bank_transactions`](https://docs.tight.com/ai/mcp-tools/bank-transactions-mcp#query-bank-transactions)
    MCP tool now supports cursor pagination and an `lastUpdatedDatetime` filter, and `update_bank_transaction` now enables
    manually matching transfers and refunds.

  ### Conversations

  * [Conversations](/api-reference/conversations/save-conversations) now support a `DRAFT` `resolutionStatus`; messages
    added to a draft conversation are not visible to the business owner until the conversation is finalized.

  ### General Ledger

  * The [General Ledger entries query](/api-reference/gl-entries/query-gl-entries) now accepts a `dimensionValues`
    filter, with running balances computed within the filtered set.

  ### Embedded UI

  * Transaction form events are now delivered through a single `transactionForm` listener in
    `useEmbeddedEventListeners`.
  * Dimension filter and group-by controls on the Profit & Loss report in the
    [`ReportDashboard`](/embeddable-ui/react/financial-statements/report-dashboard) component are now enabled for all
    partners.
  * Keyboard navigation is improved across [embedded components](/embeddable-ui/tight-embeddable-ui): transactions
    dashboard rows can be focused with Tab and opened with Enter or Space, and form fields, including the vendor and
    customer selectors, are now reachable with Tab.

  ## **Existing v5 Features Upgraded to v6**

  ### Embedded UI

  * The [Balance Sheet](/api-reference/reports/balance-sheet) and
    [Cash Flow Statement](/api-reference/reports/cash-flow-statement) reports are now available in the
    [`ReportDashboard`](/embeddable-ui/react/financial-statements/report-dashboard) component alongside Profit & Loss.

  ### General Ledger

  * [General Ledger entries](/api-reference/gl-entries/query-gl-entries) now return the full General Ledger account
    object on each entry and an `entity.secondaryDisplayName` that contains a secondary description of a transaction: for
    bank transaction: the bank account, for invoices: the customer, for bills: the vendor.

  ## **Fixes**

  ### Bank Transactions

  * Unsplitting a transaction (removing all of its child line items) no longer leaves it reported as a split parent
    transaction.
  * Instant or manual payouts from a connected payment processor now match to the corresponding bank transaction and
    categorize automatically, instead of remaining unmatched.

  ### Vendors

  * Saving a vendor that conflicts with an existing vendor now returns a `409` error suggesting merging duplicate
    vendors, instead of a generic concurrent-request message.

  ### Integrations

  * QuickBooks: migrations now import beginning balances for accounts nested at any depth in the balance sheet;
    accounts more than five levels deep were previously skipped.
  * Unit: bank accounts reopened on Unit's side are now reactivated automatically during sync, accounts closed in Unit
    are marked removed, and accounts a user manually deactivated stay inactive.
  * Plaid: [integrations](/api-reference/integration-management/query-integrations) now include an
    `additionalConsentRequired` flag indicating when a bank connection needs re-consent to keep syncing, and embedded
    components show a "Relink for Statements" badge that launches the Plaid re-consent flow, matching v5.
  * Adyen: bank payouts are always recorded as withdrawal transactions on the user's Adyen account even when a matching
    bank transaction is not in the system

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="June 23, 2026" description="v6.8.0">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * The `update_bank_transaction` [MCP tool](https://docs.tight.com/ai/mcp-tools/bank-transactions-mcp#update-bank-transaction)
    can now split a transaction into child line items, and `query_bank_transactions` output distinguishes parent rows
    from child rows.

  ## **Existing v5 Features Upgraded to v6**

  ### General Ledger

  * The [General Ledger entries query](/api-reference/gl-entries/query-gl-entries) now supports a free-text `search`
    across an entry's description, date, and amount, returns a `type` for each entry (such as `EXPENSE`, `REVENUE`,
    `TRANSFER_IN`, or `JOURNAL_ENTRY`), and includes a `beginningBalance` for balance sheet accounts.

  ### Bank Statements

  * The v6 [bank statements query API](/api-reference/bank-statements/query-bank-statements) is now live, returning
    uploaded bank statements with their `status`, a download `url`, and the statement `period`, filterable by bank
    account.

  ### Embedded UI

  * [Embedded components](/embeddable-ui/tight-embeddable-ui) now emit events for actions such as linking a bank through
    Plaid or opening a form, which your application can handle through the new `useEmbeddedEventListeners` hook, with an
    optional `preventDefault` flag to suppress the component's built-in behavior.
  * Saving, updating, or deleting a record now gives clearer feedback; a toast notification confirms success or surfaces
    an error when it completes.

  ## **Fixes**

  ### Bank Transactions

  * Searching transactions by text containing characters outside the Latin-1 set no longer fails the request.

  ### Companies

  * [Creating or updating a company](/api-reference/company-management/create-a-company) now validates the nested
    `address`, including phone number format; addresses that previously passed without validation may now be rejected.
  * Retrieving a company no longer returns an error when there is more than one user associated with the company.

  ### Webhooks

  * Outgoing [webhook](/api-reference/webhooks) payloads larger than 4,500 characters are no longer truncated; the full
    payload is now delivered.

  ### Embedded UI

  * Fixed an issue in Chrome where opening a conversation attached to a transaction would move off the screen.

  ### Integrations

  * Stripe: a charge that is also recorded as a Plaid bank transaction no longer fails to reconcile when the bank
    transaction is processed before the charge; the charge is matched to the existing transaction instead of creating a
    duplicate.
  * QuickBooks: chart of accounts imports now handle account names containing commas, deeply nested sub-accounts, and
    accounts identified by number.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="June 9, 2026" description="v6.7.0">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * The MCP server now includes tools for querying and saving vendors and customers.

  ### Companies

  * The [bank transaction query](/api-reference/bank-transactions/query-transactions) and summary endpoints now accept a
    `company` filter to return transactions for a specific set of companies (up to five) in accountant and partner
    sessions.

  ### Embedded UI

  * Transaction review status names have been updated to be more clear, and relevant to the user's role. Business owners
    and bookkeepers each see statuses relevant to their workflows.

  ## **Existing v5 Features Upgraded to v6**

  ### Reports

  * All report API responses now return monetary amounts as integer cents (for example, `5000` rather than `50.00`);
    margin percentages remain decimal values.
  * Reports now support a `NONE` date grouping that returns a single total for the full reporting period without breaking
    it out by month or quarter.

  ### Embedded UI

  * The [`ReportDashboard`](/embeddable-ui/react/financial-statements/report-dashboard) component is now available in the
    v6 React component library. It includes the new v6 Profit & Loss report, with placeholders for forthcoming v6 reports.

  ### Bank Accounts

  * The [bank accounts query](/api-reference/bank-accounts/query-bank-accounts) endpoint now accepts an `apiName` filter
    to return only accounts from a specific source, such as `PLAID` or `MANUAL_ENTRY`.

  ### Bank Transactions

  * [Saving a bank transaction](/api-reference/bank-transactions/save-transactions) now enforces additional validations:
    the assigned General Ledger account must be a leaf account (an account with no sub-accounts), line items cannot use a
    bank-transfer account, and any referenced vendor must be active.

  ### General Ledger

  * Querying [General Ledger entries](/api-reference/gl-entries/query-gl-entries) is now live in v6, returning each
    entry's account, debit and credit amounts, and a running balance, with date-range, account, and accounting-method
    (accrual or cash) filters.

  ### Integrations

  * Payabli: Payabli invoice payments and refunds now sync automatically.
  * Plaid: synced accounts are now matched by their exact account ID before falling back to the persistent account ID,
    reducing cases where transactions were linked to the wrong bank account.
  * QuickBooks: CSV imports now recognize a `Description` column header, and imports no longer fail when an invoice has no
    associated payment.

  ## **Fixes**

  ### Embedded UI

  * Payment processor accounts (such as Stripe) no longer appear on the bank account card on transaction dashboards; they
    remain available under Banks & Integrations.
  * The sender column in the conversations list now populates correctly.
  * Over- and underpayment warnings on invoice line items are now legible on dark backgrounds.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="May 28, 2026" description="v6.6.0">
  ## **New Features & Enhancements**

  ### Authorization

  * Read-only access tokens are now available; they retain full read access, are rejected on write endpoints.

  ### Bank Transactions

  * Bank transactions now support foreign currency in v6: [save](/api-reference/bank-transactions/save-transactions) accepts an
    `originalCurrency`, and [responses](/api-reference/bank-transactions/query-transactions) include a `currencyInfo`
    object with `originalCurrency`, `originalAmount`, and `exchangeDate`.
  * Transaction dashboards now use a responsive card header (review status, bank account, and chart) that collapses to a
    single column on narrow screens.

  ### Dimensions

  * Dimension hierarchies are now limited to three levels, and bank transactions and payments accept a maximum of four
    dimension values each.

  ## **Existing v5 Features Upgraded to v6**

  ### Taxes

  * Canadian GST, HST, PST, and QST sales taxes are now auto-calculated and
    [General Ledger account](/api-reference/gl-accounts/query-gl-accounts) responses include a `taxCategory` field on
    expense accounts.

  ### Customers

  * Query, save, get, and delete endpoints for the [customers](/api-reference/customers/query-customers) API (formerly
    clients in v5) are now live in v6, with search by name and email on the query endpoint.

  ### General Ledger Accounts

  * The [get](/api-reference/gl-accounts/get-gl-account) and [delete](/api-reference/gl-accounts/delete-gl-account)
    General Ledger account endpoints are now live in v6.

  ### Reports

  * The [Profit & Loss](/api-reference/reports/profit-and-loss) report is now included in v6 Components. Users can
    generate P\&L reports on both an accrual or cash basis with filtering and grouping by dimension.
  * The [Trial Balance](/api-reference/reports/trial-balance) report API is now live in v6.
  * [Profit & Loss](/api-reference/reports/profit-and-loss) responses now include the grouping entity, such as a
    dimension, when results are grouped.
  * The [Profit & Loss](/api-reference/reports/profit-and-loss), [Balance Sheet](/api-reference/reports/balance-sheet),
    [Trial Balance](/api-reference/reports/trial-balance), and
    [Cash Flow Statement](/api-reference/reports/cash-flow-statement) report APIs now accept an empty request body,
    defaulting the reporting period.

  ### Companies

  * The [company query](/api-reference/company-management/query-companies) endpoint is now live in v6, returning the
    companies accessible to an accountant or partner token.

  ### Bank Transactions

  * [Bank transaction](/api-reference/bank-transactions/query-transactions) responses now include a `company` object for
    accountant and partner sessions, identifying the owning company in cross-company queries.
  * `lastUpdatedDateTime` is now returned in [bank transaction](/api-reference/bank-transactions/query-transactions)
    responses.
  * `subType` (for example, `CHECKING`) is now returned in bank account responses, matching v5.
  * Users can now manage vendors and customers in the new v6 transaction settings menu.

  ### Integrations

  * Payabli: new payment processing integration that syncs Payabli charges, payouts, and transfers as bank transactions.
  * Plaid: relinking a bank connection no longer re-imports transactions that were already synced, preventing duplicates.
  * Qualpay: activation now submits the complete tax identification and bank account details required to enable the
    processor.

  ## **Fixes**

  ### Embedded UI

  * On the [`FinancialOverview`](/embeddable-ui/react/financial-overview) dashboard, DIY (do-it-yourself) companies no
    longer see the Conversations, Financial Summary, and Message Bookkeeper sections.
  * Category and account SVG icons now properly support theme customization.
  * Default filters have been standardized across all transactions dashboards and tables.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="May 12, 2026" description="v6.5.0">
  ## **New Features & Enhancements**

  ### Reports

  * The recently upgraded v6 Balance Sheet report supports filtering and grouping by dimension, enabling
    multi-dimensional, end-to-end [dimension values](/guides/business-owners/dimensions) on any labels you define through
    the dimension labels API.

  ## **Existing v5 Features Upgraded to v6**

  ### Payments

  * The [save](/api-reference/payments/save-payments), [query](/api-reference/payments/query-payments),
    [get](/api-reference/payments/get-payment), and [delete](/api-reference/payments/delete-payment) payment endpoints are
    now live. Payment IDs use the `ptxn_` prefix and child line item IDs use the `tli_` prefix; `date`, `amount`, and
    `description` are required on save.

  ### Reports

  * The [Balance Sheet](/api-reference/reports/balance-sheet) report API is now live in v6.

  ### Bank Transactions

  * [Save bank transactions](/api-reference/bank-transactions/save-transactions) now accepts
    [payments](/api-reference/payments/save-payments) as children. `paymentId` field added to
    [bank transaction](/api-reference/bank-transactions/query-transactions) child responses, identifying the linked
    payment.

  ### Bills

  * [Bills query](/api-reference/bills/query-bills) now supports a `billStatus` filter with `in` and `notIn` arrays,
    alongside the existing `status` filter.

  ### Companies

  * `phoneWork` on [company addresses](/api-reference/company-management/create-a-company) is now restricted to US and
    Canada [E.164](https://www.itu.int/rec/T-REC-E.164) format. International numbers outside of US and Canada will be
    rejected.

  ### Embedded UI

  * New payment selector on v6 [bank transaction forms](/embeddable-ui/react/bank-transactions/transaction-form) lets
    users link [payments](/api-reference/payments/save-payments) (e.g., Stripe charges) to a parent bank transaction
    (e.g., a payout). Drawer-based selection includes search, filters, and total validation.
  * Overpaid and Underpaid status labels added to invoice and bill line item sections on bank transaction forms, surfacing
    mismatches between the transaction amount and linked line item totals.
  * Review status display now shows role-specific labels: accountants see Discrepancy, Client Review, Needs Review, and
    Staged; business owners see Needs Review, Discrepancy, Processing, and Reconciled.

  ### Integrations

  * Plaid: bank sync now backfills any transactions missed by the standard sync within the configured date range.
  * Gusto and Check: payroll expense matching now uses provider-specific logic. Gusto matches across all payroll fields
    including benefits, while Check matches only the total debit amount.

  ## **Fixes**

  ### Embedded UI

  * Tab key now traverses all form fields including date picker months and stays trapped within drawer forms.

  ### Bank Transactions

  * Queries with enum-valued status filters (such as `reviewStatus`) on
    [bank transactions](/api-reference/bank-transactions/query-transactions) now return the correct rows.
  * [Save bank transactions](/api-reference/bank-transactions/save-transactions) no longer accepts new transactions that
    are not Active.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="April 28, 2026" description="v6.4.0">
  ## **New Features & Enhancements**

  ### Webhooks

  * New [`bankNotLinkedAfterOnboarding`](/api-reference/webhooks) webhook event fires when a company completes onboarding
    without linking a bank account.

  ### Embedded UI

  * New `TightApp` component wraps multi-page embedded experiences with built-in navigation, drawer state tracking, and
    anchor scrolling.

  ### Companies

  * `phoneWork` on [address](/api-reference/company-management/create-a-company) now requires
    [E.164 format](https://www.itu.int/rec/T-REC-E.164) (e.g., `+14155551234`). v5 did not enforce this format, so
    payloads accepted by v5 may need to be reformatted before they pass v6 validation.

  ## **Existing v5 Features Upgraded to v6**

  ### Bank Transactions

  * [Bank transactions](/api-reference/bank-transactions/query-transactions) filter `lastUpdatedDate` renamed to
    `lastUpdatedDateTime` and now publicly documented.
  * `amount` field on [bank transaction](/api-reference/bank-transactions/save-transactions) child line items is no longer
    required.

  ### Invoicing

  * [Invoices query](/api-reference/invoicing--invoices/query-invoices) endpoint now supports an `invoiceStatus` filter
    with `in` and `notIn` arrays. The existing `status` filter is retained.

  ### Embedded UI

  * The alert component now uses a responsive layout.

  ### Integrations

  * Stripe: balance transactions with `financing_paydown` reporting category now categorize to the Loan Payable expense
    category.

  ## **Fixes**

  ### Embedded UI

  * Table rows no longer overflow their parent container on hover.
  * Bank account rows no longer show "Processing" sub-text after the first sync completes; the label is now scoped to
    accounts that have `syncTransactions` enabled but no `lastSyncedDate`, and "Not Synced" is scoped to accounts with
    `syncTransactions` disabled.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="April 14, 2026" description="v6.3.0">
  ## **New Features & Enhancements**

  ### Dimensions

  * Dimension values now enforce parent-child hierarchy validation, automatically inferring the parent when a child
    dimension value is provided.
  * `child` field on a dimension is now nullable, supporting leaf-level dimensions without children.

  ### Embedded UI

  * Cash Flow and Expense tiles on the [Business Owner Dashboard](/embeddable-ui/react/financial-overview) now
    display month-over-month comparison chips.
  * [Business Owner Dashboard](/embeddable-ui/react/financial-overview) transaction section now renders on mobile
    with search and review capabilities.

  ## **Existing v5 Features Upgraded to v6**

  ### Bank Transactions

  * [Bank transaction](/api-reference/bank-transactions/query-transactions) `type` field simplified to four public values:
    `EXPENSE`, `REVENUE`, `TRANSFER_IN`, `TRANSFER_OUT`. Endpoints still accept previous values via version negotiation.
  * `reviewStatus` values consolidated. Endpoints still accept previous values via version negotiation.
  * `vendor` field on [bank transaction](/api-reference/bank-transactions/query-transactions) responses now returned only
    on expense-type transactions.
  * ID format validation now enforced on reference fields (`customerId`, `categoryId`, `glAccountId`, `invoiceId`,
    `billId`, `payrollId`) when [saving transactions](/api-reference/bank-transactions/save-transactions).
  * Maximum attachment count validation now enforced on
    [bank transaction](/api-reference/bank-transactions/save-transactions) save operations.

  ### Bills

  * [Bills query](/api-reference/bills/query-bills) endpoint now supports `search` filter and `DATE_PROXIMITY` sort
    option.

  ### Invoicing

  * [Invoices query](/api-reference/invoicing--invoices/query-invoices) endpoint now available in v6 with `search` filter
    and `DATE_PROXIMITY` sort option.

  ### Payroll

  * [Payroll query](/api-reference/payroll/query-payroll) endpoint now available in v6 with `search` filter. `amount`
    field type widened from `Integer` to `Long`.

  ### Customers

  * [Customer query](/api-reference/customers/query-customers) endpoint now supports `email` filter and `EMAIL` sort
    option. `createdDateTime` field added to the response.

  ### Embedded UI

  * Drag-and-drop attachment support now available on
    [bank transaction forms](/embeddable-ui/react/bank-transactions/transaction-form).
  * Customer selection modal with search and inline create added to bank transaction forms.
  * Radio button indicators now display on single-select filter lists across dashboards.
  * [Expense Dashboard](/embeddable-ui/react/bank-transactions/expense-dashboard) and
    [Income Dashboard](/embeddable-ui/react/bank-transactions/income-dashboard) now available as standalone component
    exports.
  * Bank transaction form now submits only modified fields, reducing unnecessary writes.

  ## **Fixes**

  ### Bank Transactions

  * Fixed revenue and expense validation when itemizing transactions.
  * Fixed parent dimension value form validation on bank transaction forms.
  * Fixed API error in [bank transaction summary](/api-reference/bank-transactions/query-transactions) when `groupBy`
    parameter is omitted.

  ### Embedded UI

  * Dashboard charts now update when transactions change and no longer query removed bank accounts.

  ### Webhooks

  * Fixed persistence of non-latin1 characters in outgoing [webhook](/api-reference/webhooks) payloads.

  ### API

  * Standardized error response for requests with missing request body.
  * List filter parameters no longer cause errors when containing null values.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="March 31, 2026" description="v6.2.0">
  ## **New Features/Enhancements**

  ### *Bank Transactions*

  * Introduction of the [Expense](/embeddable-ui/react/bank-transactions/expense-dashboard) and [Income](/embeddable-ui/react/bank-transactions/income-dashboard) Dashboards in React Components.
  * Ability to configure support for multi-dimensional transaction itemization, allowing end users to itemize transactions by customer and class segments such as location and department.
  * Support for attaching invoices and bills to [bank transactions in v6 API](/api-reference/bank-transactions/save-transactions).
  * Refactor to the `type` field on [bank transactions](/api-reference/bank-transactions/query-transactions) to introduce more granularity for display and filtering purposes.

  ### *Data Lakes*

  * New column for lastUpdatedDate on General Ledger entry transactions.
  * Added v6 IDs to transaction and lifecycle event data lake exports.
  * Inclusion of deleted and unlinked bank accounts in data lake exports.
  * Introduction of General Ledger Audit Trail in the Data Lakes.

  ## **Bug Fixes**

  ### *Invoicing*

  * Fix issue preventing cancellation of recurring invoices in the embedded UI.
  * The address field is now optional during tax filing.
  * Fix for duplicate transactions appearing in Money In after removing a matched payout from an invoice.

  ### *API*

  * Fix to 207 multi-status responses incorrectly returning 500 errors when an exception is thrown after validation passes.
  * Fix to GL account ID resolution errors when querying transactions via v6 endpoints.
  * Fix to include v6 revisions in the v5 Audit Trail API.
</Update>

<Update label="March 18, 2026" description="v6.1.0">
  ## **New Features/Enhancements**

  ### *Tax Updates*

  * Updated 2026 Canada federal and provincial tax tables and 2025 US state tax constants to reflect the latest rates and brackets.

  ### *Data Lakes*

  * New User Information data type (reflects [GET /userInfo](https://docs.tight.com/reference/getuserinfo))
  * New User Tax Profile data type (reflects [GET /userTaxSetup](https://docs.tight.com/reference/getusertaxsetup))
  * New Integrations data type (reflects [GET /integrations](https://docs.tight.com/reference/getintegrations))
  * New Time Entries data type (reflects [GET /times](https://docs.tight.com/reference/gettimes))
  * New columns for Bank Transactions: `bankTransferId` and `isPayout`

  ### *Integrations*

  * Update to Plaid integration to update vendor information if modified after the transaction has already been posted.

  ### *API*

  * V5 lifecycle event webhooks now include v6 entity IDs alongside v5 IDs, to better support the migration to v6.
  * New DELETE /v6/company/ endpoint with `ENTITY_UPDATE` webhook for company status tracking.
  * Updates to Year-End Closing logic to mark all transactions in a closed year as `RECONCILED`.

  ### *Imports*

  * Xero imports now pull client details, including  email, address, and phone number in addition to client name, for both new and existing Xero-connected users.

  ## **Bug Fixes**

  ### *Transactions*

  * Revenue Rules created from transactions by a user are no longer being created in a  'Suggested' state.
  * Improved General Ledger entry creation for Bank Transfers where the two sides fall in different months.
  * Bug fix on the Income and Expenses Dashboards to correct search for a figure ending in zero.

  ### *Reports*

  * Tax Report discrepancy fix caused by invoice sales tax being included as income in the Tax Details report.
  * Fix to Business Revenue Report to only show invoice payments associated with the filtered businesses.
  * Exception fix on Balance Sheet Report fix to render all data in totals/balances

  ### *Invoicing*

  * API Fix where `dueDate` was not defined when the invoice term was set to `OTHER`, causing errors when finalizing the invoice.
</Update>

<Update label="March 5, 2026">
  Tight MCP server and bug fixes.

  ## **New Features/Enhancements**

  ### *MCP*

  Tight’s MCP server is launched in sandbox and production. Please reach out for access.

  * Release of Financial Statements MCP tools that support generating, analyzing, and drilling down into the core financial statements: Profit & Loss, Cash Flow Statement, and Balance Sheet.
  * Release of Bank Transaction MCP tools that support reviewing, updating, and summarizing bank transaction data.

  ### *API*

  * Added ability to create parent General Ledger accounts for more advanced CoA customization.

  ### *CSV Imports*

  * Increased the maximum transaction upload limit from 500 to 2,500 transactions during CSV upload.

  ## **Bug Fixes**

  ### *API*

  * Fix when pulling Plaid institution data into Tight SDK caused by a CORS error.

  ### *Bank Transactions*

  * Bug fix to enable converting Stripe bank transfers to revenue.
  * Update to pull bank transaction data when a deleted bank account is restored.
  * Prevention of potential duplicate transactions after attaching a deposit to an invoice and subsequently moving the `tranStartDate` forward on the associated bank account.

  ### *Embedded UI*

  * Fix to SDK’s `renderAccountantUserScreen` when switching between accountant users programmatically.
</Update>

<Update label="February 19, 2026">
  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent.

  ## **New Features/Enhancements**

  ### Plaid

  * Enhancement to trigger a manual pull as a redundancy measure for any Plaid items that haven’t received a webhook for three days.

  ## **Bug Fixes**

  * Fixes when converting Stripe bank transfers to other transaction types.
</Update>

<Update label="February 5, 2026">
  Data Lake enhancements and bug fixes.

  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent.

  ## **Data Lakes Enhancements**

  * Updates to Bank Transactions Data Lakes to include pertinent General Ledger accounts for all transactions.
  * Addition of General Ledger and Chart of Accounts to Data Lakes.

  ## **Bug Fixes**

  * Idempotency fix to [DELETE /v5/expenses/expense](https://docs.tight.com/reference/deleteexpense).
  * Fixed invoice validations to allow the removal of payment processor payments that are manually linked to invoices in error.
  * Resolved a bug where draft invoices were incorrectly recorded as Services Income.
</Update>

<Update label="January 22, 2026">
  Tax Form updates, endpoint enhancements, and bug fixes.

  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent.

  ## **New Features/Enhancements**

  * **2025 US Tax Forms**: Updated Form 1040 Schedule C, Form 1065 population, Form 1120-S, and Form 1120 population for 2024 (commonly filed between April and October 2025), accessible through the Taxes Dashboard and via [API](https://www.hurdlr.com/reference/postreport).

  ## **Bug Fixes**

  * Fixed monthly recurring transaction dates by respecting the user’s timezone.
  * Bug fix to recurring invoice links to display the correct invoice PDF.
  * Bug fixes to errors when sending certain Lifecycle events related to monthly closings.
</Update>

<Update label="January 7, 2026">
  Invoice enhancements, updated lifecycle events, and bug fixes

  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent.

  ## **New Features/Enhancements**

  ### Lifecycle Events

  * New lifecycle event for bankStatementIngested for when a Plaid bank statement is ingested.
  * Addition of transactionIds to transaction edit and creation events.

  ### Invoicing

  * Improvements to automatic reconciliation for manual Stripe payouts.
  * Improved auto-matching logic for direct invoice payments against invoice recurrences.
  * Ability to cancel invoices refunded via payment processor via UI.
  * Updated invoice email UI to replace the “Review & Pay” button with “Review” when no payment link is included (e.g for direct payments).

  ## **Bug Fixes**

  * Fixed a bug causing delays to Tight’s asynchronous actions queue.
  * Fix to include invoice identifier on [POST /invoice](https://docs.tight.com/reference/postinvoice) response for newly created invoices.
</Update>

<Update label="December 16, 2025">
  Bug fixes for Invoicing, Data Lakes, and the API.

  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent. Outside of this, Tight is primarily focused on bug fixes.

  ## **Bug Fixes**

  ### Invoicing

  * Fixes to automatic payout reconciliation for manually initiated Stripe payouts.
  * Improvements to the display of CC and BCC emails on invoices.

  ### Data Lakes

  * Population of missing `userID` on `closingCompleted` events.
  * Updates to the `accountingClosingCompleted` event to include the `closedByUserId` field

  ### API

  * Fix to validation of beginning date on monthly closings.
</Update>

<Update label="December 4, 2025">
  Data Lakes updates, accounting import enhancements, and bug fixes

  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent.

  ## **New Features/Enhancements**

  ### Data Lakes

  * **Journal Entries Data Lake**: Addition of journal entries to Data Lakes.
  * **Transactions Data Lake**: Addition of GL account names for revenue transactions to Data Lakes.
  * **Bank Accounts Data Lake**: Addition of `latestTransactionDate`, `latestStatementDate`, `latestCompletedClosingDate`, and `lastWebhookDatetime` for bank accounts to Data Lakes.

  ### Invoicing

  * **Reopen Invoices**: Enhancement to allow the re-opening of canceled invoices, removing the need to duplicate them.

  ### Imports

  * **Xero / QBO:** Update to support very large file sizes for Xero/QBO imports.

  ## **Bug Fixes**

  ### Integrations

  * Compliance updates to hide the email field in Mixpanel events by default.

  ### Reports

  * Fix to prevent reports from being cut off in preview UI.
  * Fix to exclude newly archived invoices from report totals and Profit & Loss calculations.

  ### Invoicing

  * Bug fix to payout-matching for Stripe payouts to prevent double-counting income and ensure accurate reconciliation for Stripe payouts.
</Update>

<Update label="November 5, 2025">
  Bug fixes for invoicing, transactions, reports.

  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent. Outside of this, Tight is primarily focused on bug fixes.

  ## **Bug Fixes**

  ### Invoicing

  * Fix to invoice total calculation enabling users to close invoices when sales tax and discounts are applied.
  * Update to correctly order the consumption of Stripe webhooks to ensure invoice payments are kept up-to-date with the Stripe API.
  * Bug fix to the default invoice template to prioritize the invoice email over the default client email.

  ### Transactions

  * Fix enabling users to split expenses over multiple bills.

  ### Reports

  * Fix to the Expense and Income by Client reports to correctly display 'No Client' for expenses without clients, ensuring the report matches the Transactions Dashboard UI.
</Update>

<Update label="October 16, 2025">
  New Data Lakes, improvements to Bank Transactions, and bug fixes.

  ## **New Features/Enhancements**

  ### Data Lakes

  * **Transactions Data Lake**: Addition of reviewStatus and client information to transactions data lake.
  * **Balance History Data Lake**: New data lake for bank account balance history for Plaid-connected accounts.
  * **Closings Data Lake**: Addition of monthly closings to Data Lakes.
  * **Rules Data Lake**: Addition of expense and income rules to Data Lakes.

  ### Transactions

  * **Unit Integration**: Unit integration updates to improve bank transaction refund matching.
  * **Transactions Logic**: Updates to prevent the removal of invoiced expenses.
  * **Receipt Display**: Updates to receipt logic to show file name if there is no thumbnail for clear distinction of receipts to attach to expenses.

  ## **Bug Fixes**

  ### Accounting

  * Fix to show an alert when creating a new bank reconciliation with a date range that includes an existing Beginning Balance Journal Entry.
  * Resolved an error preventing year-end closing prior to all reconciliations being completed including inactive reconciliations.
  * Added validations to ensure inactive GL Accounts cannot be assigned as revenue accounts for transactions.

  ### Invoicing

  * Fixed an issue where Stripe payments were not properly updating invoice statuses, ensuring invoices now move from “Processing” to the correct “Paid” status once payments are received.
  * Fix to remove duplicate invoice entries in the General Ledger.
  * Correction to automatic reconciliation of direct invoice payments to exclude invoices with processing payments.
  * Bug fix to properly receive webhooks from Stripe for correct invoice payment processing.
  * Fixes to Stripe payout matching based on Stripe webhook data.
</Update>

<Update label="September 25, 2025">
  OBBBA Tax Updates, Data Lake additions, and big fixes.

  ## **New Features/Enhancements**

  ### Taxes

  * **One Big Beautiful Bill Act (OBBBA) 2025 Tax Changes**: Rollout of 2025 tax code changes introduced by the OBBBA, including standard deduction number updates, child tax credit increases, adjustments to the Qualified Business Income Deduction calculation, SALT limitation increases, and added support for tip and overtime deductions.

  ### Data Lakes

  * **Data Lakes Additions**: Bank transaction rules, monthly closings, and a history of bank account balance data are now all available in the [Tight Data Lakes](https://docs.tight.com/docs/data-lakes).

  ### Bills

  * **Partial Bill Payments**: Added support for partial payments, allowing multiple expenses to be applied to a single bill and validating against the remaining balance rather than requiring an exact match.
  * **Bills API Identifier**: New custom identifier on the [POST /bills endpoint](https://docs.tight.com/reference/postbills) allowing external identifiers to be added to Bills.

  ## **Bug Fixes**

  ### API & Embedded UI

  * Added validation on [DELETE /payment](https://docs.tight.com/reference/deletepayment) to validate against the deletion of Stripe card/ACH payments.
  * Bug fix to allow the merging of bank accounts or updating of the start date even when the account requires a relink with Plaid to enable statements.
  * Bug fix to correctly remove all historical transactions [bank account deletion](https://docs.tight.com/reference/deletebankaccount) when `removeAllTransactions` is true.
  * Optimizations to application of [template rules](https://docs.tight.com/reference/postsetupexpenserules) to existing users.
  * Fix to prevent crashes on Vendor UI forms.

  ### Invoicing

  * Fix to properly label Time & Tasks so they no longer show as INVOICED when no longer attached to an invoice.
  * Bug fix to allow the ability to input a full ZIP code in the Business Information section of Invoice Settings.
  * Updates to automatically split long invoice messages onto two pages when they exceed a certain length.
  * Bug fix to automatically create a Stripe customer when a client adds their default billing information to ensure they can be automatically charged.
</Update>

<Update label="September 3, 2025">
  Bug fixes for transactions, and integrations, and invoicing.

  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent. Outside of this, Tight is primarily focused on bug fixes.

  ## **Bug Fixes**

  ### Bank Transactions

  * Fixes to update the `tranStartDate` on re-linked Plaid accounts to be the date of the latest transaction from the originally linked account to more precisely prevent duplicates.
  * Bug fixes to correctly set `currencyType` on bank transactions from Plaid, Unit, and other integrations.
  * Bug fixes to bank account merging when there are manual journal entries between the two bank accounts.
  * Fixes to support CSV imports that create matching bank transfers with existing transactions.

  ### Integrations

  * Fixes and improvements to Stripe payout matching related to instant and reversed payouts.
  * Added validations preventing Stripe payments from being bulk deleted on the Income Dashboard, avoiding issues with payments that were already paid, archived, and duplicated for invoices.

  ### Invoicing

  * Bug fix to correctly update GL entries for paid invoices when an item's income account has been updated.
  * Bug fix to allow expenses and time & tasks to be deleted from an invoice and re-attached to other invoices.
  * Updates to properly calculate the invoice total when attaching manual payments to invoices for expenses and/or time entries.
  * Updates to the [/refundInvoice](https://docs.tight.com/reference/postrefundinvoice) endpoint so refunds correctly mark the paymentMethod instead of defaulting to DIRECT.
  * Fix to correct business logo alignment on invoice PDFs.
  * Fix to allow edits to recurring invoices in closed years.
</Update>

<Update label="August 14, 2025">
  Asynchronous CSV imports, improved API validations, and bug fixes.

  ## **New Features/Enhancements**

  ### CSV Imports

  * Enhancement to make CSV imports asynchronous to prevent timeouts with larger files.
  * Addition of a new banner to let users know when a CSV Import is in-progress, failed, or completed.
  * Ability to view results after a CSV Import including the number of successful imports and a list of transactions that failed to import, if applicable.

  ### Invoicing

  * **Scheduled Invoices**: Ability to print scheduled invoices prior to their being finalized.
  * **Invoice Reminders**: Enhancement to send the invoice reminders and scheduled invoices during the day instead of at night, ensuring clients receive invoice reminders during daytime hours.
  * **Direct Payment Matching**: Improvements to direct payment matching including a wider date range and better tie-breaking.
  * **Sales Tax Updates**: Added API validation to restrict discounts to percentages when sales tax is applied at the item level, ensuring accurate tax calculations.

  ### Embedded UI

  * **Tooltips Update**: Addition of tooltips to the Filter and Sync buttons on the Banks & Integrations screen.
  * **Last Synced Update**: Update to display the last attempted data pull time on the "Last Synced" date instead of the last successful pull.
  * **Revenue Rules**: Users can now create revenue rules from any revenue entry in the Embedded Experience.

  ### Webhooks

  * **Integration Error Events**: Updates to the Integration Error lifecycle events to include more API error metadata.

  ### Accounting

  * **Monthly Closing Validations**: Added validations to prevent monthly closings from having overlapping dates for the same bank account.

  ## **Bug Fixes**

  ### API

  * Performance improvements when reconciling bank accounts with many transactions to ensure all transactions are marked as reconciled efficiently.
  * Fixes to correctly return the `apiTransactionId` for bank transfers.

  ### Invoicing

  * Fix to properly display invoice attachments on recurring invoices.
  * Improvements to prevent all changes to a duplicated invoice from being reverted when the ‘Back’ option is selected.

  ### Integrations

  * Improvements to bank account deduplication logic when there have been many unlinks and relinks of the same bank connection.
  * Bug fix to update Rutter transactions to display the underlying integration’s name as the GL account name instead of "Rutter."
  * Improvements to ensure transactions from Unit accounts pull in correctly and match payouts for accurate balances and totals.
  * Bug fix to deactivate Bank Accounts during refresh when Plaid has removed them
  * Fixes to Stripe matching in tie-breaking cases by using both the transaction’s identifier and the underlying source’s identifier.
  * Bug fix to hide the Scheduled Closings feature on the Banks & Integrations screen if Plaid is not linked or bank reconciliations are not enabled.

  ### Transactions

  * Fix to prevent flickering when saving an Expense Rule.
  * Bug fix to allow recurring expenses to be deleted from the general ledger, journal, or balance sheet drilldown.
  * Updates to properly create a revenue entry when auto classify is enabled and a payment is converted to revenue.
  * Ensure matched bank transfers have a status of matched instead of active.
  * Bug fix to set bank account’s transaction pull date as the earliest transaction date during a bank merge.
</Update>

<Update label="July 24, 2025">
  Client contact details on invoices, Unit integration improvements, and V6 transactions summary API.

  ## **New Features/Enhancements**

  ### Invoicing

  * **Client Contact Details**: Expanded client contact details to support storing additional information such as address, phone number, and more.
  * **Stripe Payouts**: Enhancements to Stripe payout matching to better support and reconcile payout reversals.

  ### Integrations

  * **Unit Improvements**: Visual and organizational enhancements to Unit bank accounts in the Embedded UI along with support for setting start dates, pausing transactions, and setting beginning balances.
  * **Stripe Permissions**: Ability for customer partners to block their users from unlinking integrations. Please reach out if you would like to enable this functionality.
  * **Banks & Integrations**: UI improvements to the Banks & Integrations screen including updating icons and expanding the clickable area of each row for better usability.

  ### API

  * **V6 Summary API**: Ability to [summarize bank transaction data](https://docs.tight.com/v6.0/reference/getbanktransactionssummary) in the V6 API.
  * **Closings API**: Addition of a new [POST /closings](https://docs.tight.com/reference/postclosings) endpoint.

  ## **Bug Fixes**

  ### Transactions

  * Updated default expense naming on the General Ledger Dashboard to display the Vendor name instead of "Manual Expense".
  * Bug fix to ensure that all expenses in a recurring series are updated when the bank account is changed.
  * Fixes to not alter the start date on bank account merges to avoid transactions from being removed.
  * Corrected rule matching logic to support transaction description and vendor-based matches, improving rule application on historical transactions.

  ### Accounting

  * Fix to exclude invoice payments and manual journal entries from bank reconciliation when their dates fall outside the reconciliation range.
  * Ability to edit the equity side of a Beginning Balance entry.
  * Corrected logic to ensure beginning balance entries are properly disconnected from bank accounts when those accounts are deleted to allow the modification of that entry.
  * Bug fix to properly save a bank account's Beginning Balance in the "Edit a Bank Account" view.

  ### Integrations

  * Fixes for accurate currency filtering for transactions ingested as part of the Rutter integration.
  * Payroll fixes to display the integration’s name properly on all payroll forms.

  ### Reports

  * Bug fix to support GL exports when descriptions contain multiple line breaks.

  ### Invoicing

  * Added validations to prevent deposits from being automatically matched to recurring parent invoices, ensuring the invoice continues to recur as intended.
  * Fix to properly convert invoice payments back to their original bank transaction once removed from an invoice.
  * Fixed a UI issue where long client names were not displaying properly when adding payments to invoices.
  * Updates to allow the removal of direct Stripe payments from invoices if an incorrect payment is applied.
  * Corrected a bug that triggered the "Update Recurring Invoice" alert when only modifying the associated bank transaction.
</Update>

<Update label="July 2, 2025">
  Bank statements integrated into Closings UX, V6 Bank Transactions query API, and bug fixes.

  ## **New Features/Enhancements**

  ### Integrations

  * **Bank Statements Integration**: Integration with Plaid’s Statements API to allow bookkeepers to pull Bank Statements directly into the Monthly Closing UX.
  * **Rutter**: Ability to programmatically set the minimum transaction date for bank accounts connected with Rutter.
  * **Gusto**: Improved dates on General Ledger entries for Gusto payrolls.

  ### API

  * **V6 Bank Transactions Query API**: Early access to the [V6 Bank Transactions Query API](https://docs.tight.com/v6.0/reference/querybanktransactions).  Note: there is still a possibility for backwards-incompatible changes as the Tight API team finalizes this new API.
  * **Tax Estimates API:** Enhanced detail and additional fields for tax credit calculations on the [tax estimates API](https://docs.tight.com/reference/postgetestimates).
  * **Delete bank account API**: New [DELETE /account API](https://docs.tight.com/reference/deletebankaccount) to provide the option to delete all associated transactions when deleting a specific bank account.
  * **Invoicing API**: Addition of a `salesTaxPercentage` on [invoice line items](https://docs.tight.com/reference/postinvoice), useful for adding percent sales tax on invoices.
  * **Entity Update Webhook:** Updates to send [entity update webhooks](https://docs.tight.com/docs/webhooks#entity_update) upon bank account creation/reactivation.

  ### Transactions

  * **Transaction visibility:** UI update to show the whole transaction description in a tooltip when it is too long to fit on the transaction row.
  * **New Vendor Update**: Update to auto-populate the new vendor field when searching for a vendor.

  ## **Bug Fixes**

  ### Transactions

  * Correction to the Expense Dashboard overview to no longer include recurring parent transactions.
  * API fix to correctly set the review status when tagging deposits as an invoice payment.
  * Fix to properly bulk tag income categories on the Transaction Dashboard.
  * Bug fix for an issue causing bulk deletion of expenses on the Transactions Dashboard to fail.
  * Fixed an issue where pagination was not always correctly shown on the Vendor List.

  ### Accounting

  * Corrections to display the field validation on a bank reconciliation’s start date when in a closed year.
  * Fixes to remove any extra characters in transaction descriptions when downloading the General Ledger report.
  * Fix to allow accountants to search for users on the teammates form.
  * Fix to update the existing beginning balance entry when adding a monthly closing with a start date prior to that beginning balance entry.
  * Corrected validations to prevent overlapping monthly and yearly closings.

  ### Integrations

  * Fix to the Rutter integration for Shopify transactions to improve payout matching.
  * API fix to correctly dedupe bank accounts when a Plaid Item is unlinked and subsequently relinked.

  ### Invoicing

  * Fix to exclude archived/canceled invoices when selecting the next invoice number.
</Update>

<Update label="June 12, 2025">
  Improvements to the Rutter integration, API access to the Aged Accounts reports, and bug fixes.

  ## New Features/Enhancements

  ### Integrations

  * **Rutter Updates:**
    * Enhancements to the Rutter integration to include the order identifier on pertinent bank transactions.
    * Updates to the Rutter integration to exclude transactions that do not match the user's currency.
    * Changes to ingested transactions to exclude the Rutter description and instead display only the underlying integration’s name.
  * **Integrations Endpoint:** Update to the [GET /integrations](https://docs.tight.com/reference/getintegrations) endpoint to support `lastUpdatedDate` and to include additional API fields.
  * **Stripe Update:** Added idempotency to [POST /stripeAccountId](https://docs.tight.com/reference/poststripeaccountid) endpoint.

  ### Reports

  * **Aged Accounts Payable:** Addition of the [Aged Accounts Payable report](https://docs.tight.com/reference/postagedaccountspayable) to the API.
  * **Aged Accounts Receivable:** Addition of the [Aged Accounts Receivable report](https://docs.tight.com/reference/postagedaccountsreceivable) to the API.

  ### Embedded UI

  * **Expense Categories:** Ability to create an expense category directly from the general ledger account form.
  * **Rule Logic:** Improved rule conflict resolution UX when adding a new rule matching archived rules, giving the option to confirm whether to overwrite or delete the original.
  * **Invoice filtering:** Improvements to filtering and sorting algorithms for potential bank transaction payment matches on the invoice form.

  ### Taxes

  * **Tax Setup**: Enhancements to the Manual Filing Jointly tax flow to provide additional context for each field and minor label edits for clarity.
  * **Tax Filing Data:** Introduction of tax filing data to Data Lakes, matching [GET /taxFilings](https://docs.tight.com/reference/gettaxfilings).

  ## Bug Fixes

  ### Bank Transactions

  * API validation fix to require a child category to be used when categorizing expenses.
  * Improvements to correctly load transactions with a trailing zero during a search.
  * Bug fix to show the correct GL account on tax payments on the Transactions Dashboard.
  * Bug fix to ensure matching bank transfers are correctly merged during bank merges.

  ### Accounting

  * UI fixes to the companies drop down on the accountant dashboard.
  * Fix to correctly render older year-end closing entries when opened from the journal.
  * Corrected validation when attempting to create a monthly closing on an unsupported bank account.

  ### Bank Linkage

  * Fix to Plaid relinks to not sync unsupported bank accounts.

  ### API

  * Bug fix to correctly handle invalid JSON requests as client errors instead of server errors.
  * Fixes to [GET /payment](https://docs.tight.com/reference/getpayments) to only include `bankTransferId` when the payment is part of a payout.
</Update>

<Update label="May 22, 2025">
  Enhanced bank linkage flows, improved vendor management, and bug fixes.

  ## New Features/Enhancements

  ### Bank Linkage

  * **Initial Plaid Linkage:**
    * New prompts to merge existing duplicate bank accounts (e.g. from a QBO migration) into newly linked accounts upon initial Plaid bank account linkage.
    * Notification of which newly linked accounts have unsupported account types or sub types upon initial Plaid bank account linkage.
  * **Banks & Integrations list:**
    * Linked bank accounts are now separated by institution, with new institution level actions.
    * Introduction of Synced and Not Synced filters.
  * **Historical Pull:** Ability to pull historical transactions to a specific date at both the institution and the bank account levels.
  * **Beginning Balances:** Ability to set and edit beginning balance entries directly from the bank account form.
  * **Bank Account Merge:** Option to merge duplicate accounts for multiple accounts at once with improved validations to prevent duplicate bank transactions.
  * **GL Account Naming:** Updates to keep GL account names in sync with updates from Plaid.
  * **Mask Limitations**: Fixes for bank accounts whose mask has less than 4 characters.

  ### Vendor Management

  * **Accountant Access**: Accountants now access the Vendor Dashboard for improved vendor management on behalf of users.
  * **Vendor table**: New columns for Default Category and Expense Rules on the Vendor Dashboard to allow for more efficient vendor management.
  * **Vendors API**: New enhancement to allow the ability to search by vendor name on [GET /vendors](https://docs.tight.com/reference/getvendors) endpoint.
  * **Vendor Merge:** UI improvements to the vendor merge workflow for vendors with very long names.

  ### Transactions

  * **Bulk Restoration**: Ability to bulk restore archived transactions on transactions-related dashboards.
  * **Automatic Reconciliation of Direct Invoice Payments:** Improved tie-breaking when automatically reconciling direct invoice payments with invoices including matching on the invoice’s client’s name.
  * **Advanced Search**: Improvement on the Expense Advanced Search to only show GL accounts that have associated expense categories and all bank accounts, including inactive/previously linked banks.

  ### Accounting

  * **Accountant access**: Accountants can now update their user’s business information in the embedded experience.
  * **QBO Import:** Updated context in the QBO Imports ‘Learn More’ section for pulling the correct files.

  ### Analytics

  * **Transaction Events**: Addition of `transactionRecategorized` [lifecycle event](https://docs.tight.com/docs/lifecycle-event-dictionary#transaction-events) for tracking who recategorized which bank transactions.
  * **Invoice Payment Events**: Enhancement to [lifecycle events](https://docs.tight.com/docs/lifecycle-event-dictionary#invoicing-events) for invoice payments to include the source API on invoice payment-related events.

  ## Bug Fixes

  ### Bank Transactions

  * Fix to allow the creation of personal income transactions via direct [API](https://docs.tight.com/reference/postrevenues).
  * Bug fix for Rutter transactions that were being accounted for in the incorrect GL account.
  * Improvements to our CSV parsing algorithms for files with missing or blank columns.

  ### Invoicing

  * Fixes to correctly use the business email set in the invoice settings instead of the account email when sending out invoices.

  ### Embedded UI

  * Fix for the pending total to only include active bank accounts in the Historical Closings graph.
  * UI fix in the Expenses Dashboard to remain on the exact page of transactions even after transaction updates.
  * UI fixes for expenses split between multiple clients.
</Update>

<Update label="May 1, 2025">
  Introduction of the Wave Migration, a new payment processor, and template rules.

  ## New Features/Enhancements

  ### Imports

  * **Wave:** Introduction of accounting migration from Wave in embedded UI and [API](https://docs.tight.com/reference/importwave).
  * **CoA Mapping API**: New [endpoint](https://docs.tight.com/reference/postmappings) for mapping a user's CoA from their legacy accounting system into the Tight API for more complex migrations.

  ### Integrations

  * **Qualpay:** Integration with new payment processor, [Qualpay](https://docs.tight.com/docs/qualpay).
  * **Transaction Sync**: Ability to pause/unpause transaction ingestion for linked Stripe and Unit accounts directly on Banks & Integrations screen.

  ### Analytics

  * **Lifecycle Events**: Added [lifecycle events](https://docs.tight.com/docs/lifecycle-event-dictionary#transaction-events) for transaction rules.

  ### Bank Transactions

  * **Last Synced Date UI**: Bank accounts now reflect their “Last Synced Date” on the Banks & Integrations screen.
  * **Advanced Search**: Ability to filter by status in the advanced search in Expense and Income Dashboards.

  ### Invoicing

  * **Bulk deletion**: Ability to bulk delete invoice payments from transaction dashboards and via [API](https://docs.tight.com/reference/deletepayments).
  * **Recurring Invoice Emails**: Option to toggle automatic emails for future recurring invoices.

  ### Embedded UI

  * **Expense Rule Templates**: Exposed template rules in [API](https://docs.tight.com/reference/getrules) and embedded UI for bookkeepers and users to review.
  * **Monthly Closings**: Updated validation to prevent the creation of monthly closings in closed years.

  ### API

  * **Attachments:** API enhancement to filter [attachments](https://docs.tight.com/reference/getattachments) to a given entity.
  * **Bank Accounts:** Minor [API](https://docs.tight.com/reference/getbankaccounts) update to return the `integrationId` on pertinent bank accounts.

  ## Bug Fixes

  ### API

  * Fixed an issue that prevented manual journal entries from being submitted when line item descriptions were omitted.
  * Resolved a bug that reset a business’s invoice prefix when the field was omitted from API requests.
  * Fixed a bug where bank account changes on recurring expenses were not being properly saved.

  ### Integrations

  * Fixed an error preventing the auto-charge payment method from working with relinked Stripe accounts.
  * Stripe integrations and associated bank accounts are now correctly marked as archived when disconnected.
  * Ensured historical Plaid transactions are consistently pulled, regardless of webhook delivery order.
</Update>

<Update label="April 10, 2025">
  Mileage SDKs, new Analytics events, and other Invoicing & Accounting enhancements.

  ## New Features/Enhancements

  ### Mileage

  * **Native iOS SDK**: [automatic mileage tracking on iOS](https://docs.tight.com/docs/ios-mileage-tracking-sdk) mobile devices.
  * **Native Android SDK**: [automatic mileage tracking on Android](https://docs.tight.com/docs/android-mileage-tracking-sdk) mobile devices.
  * **APIs**: [GET](https://docs.tight.com/reference/getmileages), [POST](https://docs.tight.com/reference/savemileages), or [DELETE](https://docs.tight.com/reference/deletemileage) mileage records (for customer-partners building their own UX).

  ### Analytics

  * **Lifecycle Events**: Expanded Lifecycle [Webhooks](https://docs.tight.com/docs/webhooks) and corresponding [list of events](https://docs.tight.com/docs/lifecycle-event-dictionary). The new events are also available via [Data Lakes](https://docs.tight.com/docs/data-lakes) and the [Mixpanel integration](https://docs.tight.com/docs/mixpanel-integration) should you wish to track this information in aggregate.
    * While Tight recommends opting into consuming the new lifecycle webhooks, the existing webhooks remain available so as to not break existing implementation. Their documentation has been moved [here](https://docs.tight.com/docs/legacy-lifecycle-webhooks).

  ### Invoicing

  * **Automatic Reconciliation of Direct Invoice Payments**: Automatic reconciliation of bank deposits against Invoices that accept direct payments.
  * **Finalized Invoices:** Ability to edit both open and closed invoices.
  * **Invoice Refund Tracking Improvements:** Enhancement to account for invoice payment refunds on the Transactions Dashboard.

  ### Accounting

  * **Addition of Beginning Balance Field:** New API-only connection between bank account and its beginning journal entry to view beginningBalanceEntryId to properly track account balances.
  * **Payout Matching Enhancements:** Support for bank transfers as children of payouts.
  * **Reports API**: Ability to perform projections in the P\&L report in API.
  * **Accountant Endpoint**: New endpoint [GET/accountant/userInfo](https://docs.tight.com/reference/getaccountantuserinfo) to retrieve info for an accountant.

  ### Embedded UI

  * **Read-only parameter**: [Embedded UI](https://docs.tight.com/docs/embeddable-ui-getting-started#embedding-specific-components) `renderScreen` function now accepts `readOnly` option to make rendered screens read-only.

  ## Bug Fixes

  ### Invoicing

  * Fix to now properly pull search results for invoice payments on transaction-related dashboards.
  * Corrections to not show split expense parents on the invoice line item expense selection.
  * Fixes to correctly track bank transfers converted to invoice payments as debits into the bank transfer’s bank account.

  ### Embedded UI

  * UI fix to show all content in the onboarding banners on mobile devices.
  * Minor UI fix to the manual journal entry form for long GL account names.

  ### Accounting

  * Enabled the conversion between S Corp and C Corp to other entities without error.
  * Fixes to allow the frontend to convert a payout’s itemized transactions.
  * Fixes to historical payout matching, specifically when the status of itemized transactions are modified.
  * Bench-imported accounts now correctly show with other migrated accounts.

  ### API

  * API validation to prevent the deletion of default client(s).
  * Corrected validations for invalid `clientId` on invoicing APIs.
  * Correctly expose `reviewStatus` for invoice payments on [/getTransactions](/v5.0/api-reference/banks/get-transactions) endpoint.

  ### Integrations

  * Bug fix to sync new accounts from Plaid when they are opened on the connection.
</Update>

<Update label="March 21, 2025">
  Revenue account selection on Invoice line items, Aged Accounts Payable report, and Transaction Rules in the Audit Trail.

  ## New Brand

  Today, my team and I have soft-launched our new brand name, Tight, along with our new website at tight.com and new logo representing the flow and balance of debits and credits, bound together by a tight knot. This name was initially inspired by the saying “keep your books tight,” and also evoked “tight integration,” the essence of embedded accounting. Finally, it evolved into this: “When your customers do their accounting on YOUR platform – that’s Tight.”

  Our new brand is reflective of the tight partnership we have with all of you. Your feedback and collaboration has been instrumental in our growth and product evolution. We’ve been investing heavily in our product and team (50% headcount increase over the past six months) and are continuing to build out new features to meet the needs of your users.

  Otherwise, there is no other change; we are the same company, same team, and same product… we simply have a new brand name. [Hurdlr](https://www.hurdlr.com) remains as a direct-to-SMB mobile and web app for freelancers and small business. [Tight is the embedded accounting product](https://www.tight.com) that you have embedded into your software platforms to serve the small businesses that use your platform.

  Thank you, and let's continue to keep it Tight!

  ## New Features/Enhancements

  ### Invoicing

  * **Stripe Payment Processing:** Reduced Stripe merchant fees by automatically saving client payment methods.
  * **Line Item Revenue Account:** Now allows selection of a revenue account for each invoice line item.
  * **Email Errors API:** Programmatic access to setting email errors on invoices for use in Embedded UI.
  * **Refund API:** A new [endpoint](https://docs.tight.com/reference/postrefundinvoice) has been added for programmatically refunding invoices.
  * **Payment Processing Tutorial:** A new listener in the Embedded UI adds a CTA that allows customer partners to route users to a payment processing tutorial.
  * **Invoice Audit Trail:** Ability to audit changes to invoices, including a history of client interactions. This functionality is currently only accessible from the accountant-facing Embedded UI and via [API](https://docs.tight.com/reference/auditinvoice).
  * **Invoice Payments:** Minor UI update removes the prompt to set up a payment processor for an invoice when payments are already associated with that invoice.

  ### Bank Transactions

  * **Audit Trail:** The Audit Trail now logs the rule used to categorize each transaction.
  * **Rule Matching:** Expense rule matching now defaults to the most recent matching rule when multiple rules apply.

  ### Integrations

  * **Rutter:** Enhanced payout matching for the Rutter integration.
  * **Plaid:** Updated the Plaid integration to utilize the new `persistent_account_id` for better bank account de-duplication.
  * **Integrations API:** Introduced a [DELETE /integration](https://docs.tight.com/reference/deleteintegration) endpoint for disconnecting a user’s integration via the Tight API.
  * **Lifecycle Event:** Added the `INTEGRATION_REPAIRED` event to notify when an integration connection has been repaired.

  ### Reports

  * **Aged Accounts Payable:** New Aged Accounts Payable report supported via both API and UX.
  * **Aged Accounts Receivable:** Enhanced with drill-down functionality.
  * **Trial Balance:** Updated to include custom data support on GL accounts, additionally reflected in the Trial Balance Report.

  ## Bug Fixes

  ### Accounting

  * Fixed issues with deleting and restoring invoice payments.
  * Corrected signage on manual journal entries in bank reconciliations.
  * Added an alert when attempting to cancel an invoice in a closed year.

  ### Invoicing

  * Corrected the display of clients in invoice settings on mobile devices.
  * Fixed UI issues for invoice line items on mobile.
  * Resolved some issues with expanding and reordering invoice line items.
  * Enabled invoiced expenses to be reconciled.
  * Corrected the UI for the source name on direct / cash invoice payments.

  ### Bank Transactions

  * Prevented the matching of expenses to deleted payrolls.
  * Corrected the API to more consistently include default clients on bank transactions when one is not provided.

  ### Client Management

  * Fixed the API for fetching clients using a given businessId.
</Update>

<Update label="February 20, 2025">
  Release of Rutter integration, Manual Journal Entry API idempotency, and other API enhancements.

  ## New Features/Enhancements

  ### Integrations

  * **Rutter Updates:** New integration with Rutter to provide access to [their many commerce integrations](https://docs.rutter.com/support-by-endpoint?activeTab=commerce).

  ### Accounting

  * **Manual Journal Entries Update:** Support for [idempotency](https://en.wikipedia.org/wiki/Idempotence) on Manual Journal Entries API.
  * **Bank Reconciliation:** Bank Reconciliations belonging to merged or otherwise deleted bank accounts will always be accessible in the Reconciliation Dashboard.

  ### Invoicing

  * **External Invoicing Support:** Improved support for programmatically syncing Invoices from non-Hurdlr systems for tighter integrations with customer-partners’ external invoicing implementations.
  * **Invoice Payments API:** Inclusion of `invoiceId` in response for INVOICE\_PAYMENT transactions on  [POST /getTransactions](https://www.hurdlr.com/v5.0/api-reference/banks/get-transactions) endpoint for invoices.

  ### API

  * **Account Creation Errors:** Improvements to account creation error handling providing more programmatic-safe error messages.
  * **Account Restoration Authentication:** Support for Partner-level authentication on [POST/restoreAccount](https://www.hurdlr.com/reference/postpartnerrestoreaccount) endpoint.
  * **Bank Transactions:** Ability to filter by \`reviewStatuses\` on [POST /getTransactions](https://www.hurdlr.com/v5.0/api-reference/banks/get-transactions).

  ### Imports

  * **QBO Modern Report:** Updated instructions for exporting QBO’s “modern” reports when performing a [QBO Migration](https://www.hurdlr.com/docs/quickbooks-online) in the Embedded UI.

  ## Bug Fixes

  ### Accounting

  * Manual Journal Entries are correctly included when pertinent bank accounts are merged.
  * Corrections to ensure that Manual Journal Entries’ amounts display correctly on Bank Reconciliations.
  * Fixes to properly split expenses belonging to [Manually Tracked Accounts](https://www.hurdlr.com/docs/transaction-dashboard-user-guide#manually-tracked-accounts) even after being merged into a Plaid-linked bank account.

  ### Bank Transactions

  * Fixes to payout matching for advanced transaction types and negative payouts.
  * Better handling of matching Bank Transfers when deleting or updating matches.
  * Fixes to [POST/getTransactions](https://www.hurdlr.com/v5.0/api-reference/banks/get-transactions) when filtering on a specific Revenue \`id\`.
  * Pagination bug fix on [GET /expenses](https://www.hurdlr.com/reference/getinterviewexpenses).

  ### Reports

  * Fix to Financial Report drilldowns bug when multiple General Ledger accounts share the same account number.

  ### Imports

  * Bug fix to correctly handle Revenue refunds in Bench import.

  ### Invoicing

  * Correction to stop sending reminders on Invoices with a pending Invoice Payment.
  * Fix to allow opening of attachments on Invoices.
  * Ability to generate PDFs for Invoices migrated from legacy accounting platforms.
  * Fixes to include CC and BCC emails when duplicating an Invoice.

  ### Tax

  * Fixed bug causing crashes on the Tax Dashboard when rendering Embedded Experience in Spanish.
  * Correction to the constant used on line 21 of the Schedule D (Form 1040).

  ### Embedded UI

  * Bug fixes to Business Intelligence Tiles’ callback events to match their UI more accurately.

  ### API

  * Fix to allow the account creation for bizNames that are shorter than 3 characters after the removal of whitespace.
</Update>

<Update label="January 30, 2025">
  Enhancements to the Invoicing user experience, Bank Transaction functionality, and availability of 2025 Tax Filing and Estimates.

  ## New Features/Enhancements

  ### Invoicing

  * **Ability to edit finalized Invoices:** Ability for users to make edits to Invoices that have already been finalized and/or sent to their clients.
  * **API Update:** Ability to include relevant Invoice Payment data on [GET /invoices](https://www.hurdlr.com/reference/getinvoices) via new API parameter, `includePayments`.
  * **Invoice Message**: The Invoice message now allows emojis and other unicode characters.
  * **Payment Processing Options:** Ability to specify what [Payment Processing options](https://www.hurdlr.com/docs/embeddable-user-interface-invoice-dashboard#3-modifying-the-payment-processing-options) users can accept on their Invoices in the Invoice Dashboard.
  * **Recurring Invoices:** Improved UI to distinguish recurring Invoices in the Invoicing Dashboard.

  ### Bank Transactions

  * **Expense Rules:** Ability to create Expense Rules without a Vendor; transactions matching such rules will use the Vendor already associated with the given transaction.
  * **Plaid Historical Pull Improvements:** More robust validations in place during historical transaction pulls to avoid transaction duplicates for banking institutions that have been unlinked and relinked with Plaid.
  * **Import CSV:** Update to display a transaction’s description as its Vendor when a Vendor is not provided during the review flow.

  ### Tax

  * **2024 US Tax Forms**: Updated Form 1120-S and Form 1120 population for 2024 (commonly filed between April and October 2025), accessible through the Taxes Dashboard and via [API](https://www.hurdlr.com/reference/postreport).
  * **2025 Canada Tax Estimates**: Review of all 2025 Canadian tax forms and subsequent updates to Hurdlr's tax engine for precise [Tax Estimates](https://www.hurdlr.com/docs/tax-calculations) on 2025 data with full Canadian support (federal and all 10 provinces).

  ### Integrations

  * **Bank Account Refresh:** Updates to the Plaid integration  to perform additional updates on Bank Account metadata if Plaid modifies this information.
  * **Stripe Updates:** Inclusion of Stripe’s account identifier on [GET /integrations](https://www.hurdlr.com/reference/getintegrations).

  ### Imports

  * **QBO Modern Report Support**: Support for QBO’s new “Modern” reports in the [QBO Import](https://www.hurdlr.com/reference/importqbo).
  * **Import Validations**: Improved validations to the provided reports for easier self-service when performing Accounting Imports.

  ## Bug Fixes

  ### Accounting

  * Fixed bug preventing the bulk tagging of Tax Payments.
  * Fixes to GL Entry creation for matching Bank Transfers.
  * Corrections to GL account names for Plaid-linked Bank Accounts to safely include the name of the corresponding banking institution.

  ### Bank Transactions

  * Fixes to correctly update and/or unmatch a Bank Transfers matching Bank Transfer when relevant modifications are made to the match.
  * Corrected the Audit Trail to now reflect "\<Customer Partner Name> System" for all entries that are system generated.
  * UI bug fixes to now correctly show the ‘Continue’ button when merging long lists of vendors.

  ### Reports

  * Fix for directly embedding the Expenses by Category report.
</Update>

<Update label="January 10, 2025">
  New Invoicing Features: customizable business information and custom invoice numbers & formats.

  ## New Features/Enhancements

  ### Invoicing

  * **Customizable Business Information:** Users can now control exactly what appears on their invoices by customizing business details.
  * **Custom Invoice Numbers & Formats:** Ability to customize invoice numbers and formats at the Client and/or Invoice level.
  * **QBO Import Updates:** The [QBO Import](/docs/qbo-import-user-guide#uploading-reports) now accepts the "Invoices and Received Payments" report for better Invoice and Payment matching.
  * **Email Field Defaults:** Improved defaults for email-related fields in Invoicing APIs.

  ### Accounting

  * **General Ledger Report API Enhancement:** The [API](/reference/postgeneralledger) now accepts `accountNo` for a simplified method to fetch General Ledger entries for specific GL accounts across multiple user accounts.
  * **Bank Account Merging:** Deleted bank accounts with active monthly Closings will now always be included as potential duplicates.

  ### Taxes

  * **2024 Tax Forms:** Updated Form 1040 Schedule C and Form 1065 population for 2024 (commonly filed between April and October 2025), accessible through the Taxes Dashboard and via [API](https://www.hurdlr.com/reference/postreport).

  ## Bug Fixes

  ### Accounting

  * Fixed issues with drilling down into "Capital Stock," "Owner's Draw," and other related Equity accounts from the Balance Sheet.
  * Corrected the duplication of General Ledger entries for archived and converted Bank Transactions.
  * Fixed Journal Entries for Tax Payments, ensuring they update correctly when the linked bank account is changed.
  * Addressed issues with saving Bank Reconciliations when matching Bank Transfers.

  ### Bank Transactions

  * Resolved bug causing duplicate Plaid Bank Transactions.
  * Fixed display issues for manually entered transactions merged into Plaid bank accounts.

  ### Imports

  * Fixed issues with parsing Excel files during Xero Imports.
  * Updated Bench import to support their latest offboarding package.

  ### Invoicing

  * Fixed issue with archiving Invoice Payments attached to archived invoices.
  * Removed the 'Create Link' option from scheduled invoices.

  ### Payroll

  * Fixed the ability to attach Expense refunds to Payroll entries for better support of Payroll reversals.
</Update>

<Update label="December 16, 2024">
  Enhancements to user onboarding in the Embedded UI, Invoicing, and Bank Transaction classification.

  ## New Features/Enhancements

  ### Embedded UI

  * More informative CTAs on zero states for the Expense, Revenue, Invoicing, and Time & Tasks Dashboards to help drive activation.
  * Addition of [optional tooltips on each of the Business Intelligence tiles](https://www.hurdlr.com/docs/business-intelligence-tile-components#8-displaying-tile-tooltips) for better user education.
  * New copy on the rule form to provide explanations for using rules.
  * Inclusion of character counters on all text-area fields.
  * Updates to prevent accountants from editing user-level information, e.g. email.

  ### Invoicing

  * The Invoice message field now respects line breaks.
  * Ability to edit Invoice settings inline in the Embedded UI.
  * Addition of `status` filtering on [GET /invoices](https://www.hurdlr.com/reference/getinvoices)[.](https://www.hurdlr.com/docs/invoicing-api)

  ### Integrations

  * API and UX handling of [new Plaid webhooks for pending disconnects](https://plaid.com/docs/api/items/#pending_disconnect).
  * Enhancement to allow unlinked bank accounts to be merged into linked bank accounts.

  ### Transactions

  * Improvements to vendor identification and matching on CSV and Accounting imports.
  * UI and UX enhancements to the CSV Import in the Embedded UI.
  * Improved transaction details in Income reports for Invoice Payments.

  ### Accounting

  * More robust validations for General Ledger account numbers.
  * Improved automated reconciliation of withdrawals against their corresponding payrolls.
  * Accounting imports can be run on users that have already used Invoicing.

  ### Taxes

  * Tax Estimates now use the last twelve months of user data when calculating projected estimates.

  ### API

  * `userId` is now editable on [POST /userInfo](https://www.hurdlr.com/reference/postuserinfo).
  * Partners can opt-in to release the `email` uniqueness constraint on Hurdlr accounts, useful for multi-company setups. Please reach out if you would like to opt in.

  ## Bug Fixes

  ### Accounting

  * Fixes to timezone-related issues on Bank Reconciliation.
  * Fix to the creation of bi-weekly Manual Journal Entries.
  * Fix when updating a bank account’s GL account to ensure the update only impacts that bank’s transactions.

  ### Integrations

  * Correctly hide deleted imported bank accounts.
  * Fix to correctly display the bank account on manually imported transactions after being merged into a linked bank account.

  ### Invoicing

  * Fix to allow for the reordering of invoice line items.

  ### Transactions

  * Fixes to the attachment of receipts for an existing/tagged transaction.

  ### Payroll

  * Fix to improve the matching of GL account categories for payroll.
  * Bug fixes for processing and display of split Payroll expenses.

  ### Reports

  * Fix to allow emailing of all downloadable reports.
</Update>

<Update label="November 26, 2024">
  Enhancements to Invoicing and Payroll and Bank Transaction matching algorithms.

  ## New Features/Enhancements

  ### Invoicing

  * Addition of the Aged Accounts Receivable Report preview on the Invoicing Dashboard.
  * Removal of limit to number of line items on invoice form.
  * UI Improvements to visually disable ACH/CC payment options on invoices if Stripe is not linked.

  ### Integrations

  * Addition of a [new endpoint](/reference/postintegration) which allows programmatic creation of OAuth linkages in the Hurdlr API for some of our native integrations, e.g. [Stripe](/integrations/payment-processing/stripe#connect-your-user’s-stripe-accounts).
  * Inclusion of tax filing related [events for the Mixpanel integration](/docs/mixpanel-events).

  ### Accounting

  * Improvements to Payroll and Bank Transaction matching algorithms.
  * Update to completely hide duplicate bank accounts once merged.

  ### Embedded UI

  * Minor enhancement to all dashboards to only allow one field dropdown to be open at a time.

  ## Bug Fixes

  ### Invoicing

  * Fix to allow duplicating archived invoices.
  * Fixes to allow deletion of QBO/Xero imported Invoice Payments.

  ### Accounting

  * Fixes to conversions and matching of Bank Transfers during Bank Reconciliations.
  * Fixes to split expense handling in Bank Reconciliations.
  * Fixes to ensure pertinent Invoice Payments show on corresponding Bank Reconciliations.
  * Time zone fixes to correctly reflect the correct date on manual Journal Entries.
  * Fixes to tax treatment of “Dues and Subscription” expenses on the Form 1065 and tax reports.

  ### Patches

  #### 41.8.1

  * Time zone fixes for accurate transaction display on Bank Reconciliations.
</Update>

<Update label="October 31, 2024">
  Enhancements to Embedded UI versioning, Accounting Migrations, Invoicing, and Financial Reports.

  ## New Features/Enhancements

  ### Embedded UI

  * Ability to delay opting into the latest releases of the [Embedded UI](/docs/embeddable-white-labeled-experience)
    * Requires a [slight change](/docs/embeddable-ui-getting-started)  in the way the Embedded UI is added to an your application. Existing implementations are safe.

  ### Imports

  * Update to [QBO Import](/docs/quickbooks-online) to consume QBO’s "Invoices and Received Payments" report for improved invoice to payment matching.

  ### Invoicing

  * Ability to filter to scheduled invoices from the [Invoice Dashboard](/docs/embeddable-user-interface-invoice-dashboard).
  * Increased character limit of 800 for “Message” field on invoices.
  * Updates to formatting of invoice lines items on the invoice form to be clearer and more consistent with the invoice PDF.
  * Addition of dismissible Stripe Payment Processing setup CTAs.

  ### Reports

  * Improved default ordering of reports on the [Report Dashboard](/docs/report-dashboard) to be more accounting focused.

  ### Accounting

  * Addition of warning when merging bank accounts or vendors to indicate that the action cannot be undone.

  ### Transactions

  * API addition of `reviewStatus` to transaction-related APIs, e.g. [POST /getTransactions](/v5.0/api-reference/banks/get-transactions).
  * Minor language updates to conversion UI on [transaction forms](/docs/transaction-form).

  ## Bug Fixes

  ### Invoicing

  * Fixes to `customData` on [GET invoices](/reference/getinvoices).
  * Better error handling on [client invoice payment screen](/docs/embeddable-user-interface-client-invoice).

  ### Accounting

  * Fixes to respect a user’s `availableFeatures.bookkeeping` when granting and revoking access to accountants in the Hurdlr API.
  * Fix to prevent virtual bank accounts from using the same GL account.

  ### Transactions

  * Fixes to [/getTransactions endpoint](/v5.0/api-reference/banks/get-transactions) to now include active TaxPayments.
  * Fixes to bulk categorization from the [Transactions Dashboard](/docs/transactions-dashboard).
  * Fixes to correctly expand the Bank Transfer form when editing withdrawal [payouts](/docs/payout-user-guide).
  * Updates to Audit Trail to show the correct editor on the initial entry for all transactions.

  ### Patches

  #### 41.7.1 through 41.7.2

  Bug fixes and minor improvements.
</Update>

<Update label="October 17, 2024">
  Enhancements to Invoicing, Accounting, Bank Transactions, and API Authorization.

  ## New Features/Enhancements

  ### Invoicing

  * Improvements to [Stripe Integration](/docs/stripe) for increased accuracy of matching Stripe [Payouts](/docs/payout-user-guide) to their itemized transactions, including Stripe Climate Contributions and other obscure items.
  * Addition of “All” option to [Invoice Dashboard](/docs/embeddable-user-interface-invoice-dashboard) filters.

  ### Accounting

  * Ability to specify both the cash and accrual transactions on a [Manual Journal Entry](/docs/general-ledger-component) via [API](/reference/postmanualjournalentry).
  * Addition of the manualJournalEntry entity to our [Entity Update Webhooks](/docs/webhooks).

  ### Bank Transactions

  * Improvement of the display of split expenses on all transaction-related dashboards.
  * Ability to define the user-level and accountant-level access of individual transactions, via new userAccess and accountantAccess fields ([Revenue](/reference/postrevenue) for reference).
  * Ability to merge bank accounts in the Embedded UI and API.
  * Ability to merge vendors via UX and API.

  ### API

  * Introduction of Partner-level authorization

  ## Bug Fixes

  ### Transactions

  * Fixes to ingestion of [Stripe](/docs/stripe) payment data.
  * Fixes to advanced filtering and searching on [transaction tables](/guides/business-owners/bank-transactions).
  * Updates to the display of payment source information for better Invoice Payments UI.
  * Fixes to customData on [Bank Transfer](/reference/postbanktransfer) entities.

  ### Reports

  * Fixes to totals on the Aged Accounts Receivable Report.
  * Fixes to drill down on the total column on the [Profit & Loss Report](/embeddable-ui/react/financial-statements/profit-loss-report).

  ### Bank Reconciliation

  * Fix to the display of beginning balances when viewing completed Bank Reconciliations.
  * Fixes to the bank institution logos displayed on the Reconciliation Dashboard.

  ### Patches

  #### 41.6.1 through 41.6.5

  Bugfixes and minor improvements.

  #### 41.6.6

  Modifications to support SDK versioning released in 41.7
</Update>

<Update label="September 12, 2024">
  Enhancements to Bank Transactions, Invoicing, Business Intelligence Tiles, and Bills

  ## New Features/Enhancements

  ### Bank Transactions

  * All possible transaction conversions are now available via API.
  * Ability to hide the overview graphs at the top of the [Expense](/docs/expense-dashboard) and [Income](/docs/income-dashboard) Dashboards in the Embedded UI. This can be accomplished by passing an additional parameter to the Embedded UI’s render options, `showDashboardOverview: false`
  * Ability to [merge vendors via API](/reference/postvendor).
  * Addition of `apiName` field via [POST /getTransactions API](/v5.0/api-reference/banks/get-transactions).
  * Addition of a new [lifecycle event webhook](/docs/webhooks#4-lifecycle_event) for newly ingested uncategorized expenses, `EXPENSE_REVIEW_NEEDED`.

  ### Invoicing

  * Income reports updated to include invoice payments for improved consistency between these reports and their respective Embedded dashboards.
  * Improvement to bank transactions search on the invoice form.

  ### Business Intelligence Tiles

  * Ability to hide the taxes line item on [Profit & Loss Tile](/docs/business-intelligence#3-profit--loss-tile) for a more accounting-centric view. This line item will be hidden automatically for Partners who are not using the Tax Tile.

  ### Bills

  * Improvements to Bills in the Embedded UI to display the pertinent category on the bill row.

  ## Bug Fixes

  ### Accounting

  * Fixes to correctly display Manual Journal Entry dates on Journal/[General Ledger](/docs/general-ledger-component) and to ensure the ability to delete Manual Journal Entries is accessible on all entries.
  * Fixes to maintain “None” grouping filter when navigating to and from reports, e.g. for General Ledger drill downs.

  ### Invoicing

  * Invoices will be marked as refunded when all of their payments are manually refunded via API.
  * UI fixes to expanded display of Payouts on the [General Ledger Dashboard](/docs/general-ledger-component).
  * Fixes to display of merchant fees on older Payouts in the [Transaction](/docs/transactions-dashboard)/[Income](/docs/income-dashboard) Dashboards.
  * Fixes to ensure all canceled invoice payments are correctly hidden on active transaction views.
  * Fixes to some total amount validation issues when matching multiple invoices to a single deposit.
  * Ability to add [attachments without captions to invoices via API](/reference/uploadattachment).
  * Fixes to display issues for older cash payments that lacked descriptions.

  ### Transactions

  * More robust access to the Audit Trail for all transactions.
  * Updates to the Advanced Search filters to allow bank accounts without an account mask to be selected.
  * Fixes to transactions API to enable the creation of transactions without the specified client getting overwritten.

  ### Miscellaneous

  * Improvement of idempotence on transaction `DELETE` endpoints so an error is no longer returned on already deleted entities.
  * Updates to read-only users to correctly block editing of transactions in the [General Ledger](/docs/general-ledger-component).

  ### Patches

  #### 41.5.1 through 41.5.3

  Bugfixes and minor improvements.

  #### 41.5.4

  Modifications to support SDK versioning released in 41.7
</Update>

<Update label="August 23, 2024">
  New General Ledger API and improved display of the connection between the payout and its itemized transactions.

  ## New Features/Enhancements

  ### General Ledger

  * The General Ledger can be exported as a CSV directly from the [General Ledger dashboard](/docs/general-ledger-component). The new report is also available via [API](/reference/postgeneralledger).

  ### Invoicing / Payouts

  * Better display of the connection between the payout and its itemized transactions.
  * Ability to match bank transactions directly from the Invoice form.
  * Updates to cash/check payment language to reference “direct payments.”
  * Invoice payments can be deleted via [DELETE /payment](/reference/deletepayment) endpoint.
  * Improved title on the Invoice form to more accurately reflect the invoice’s status.

  ### Reports

  * Support for multi-period [Cash Flow Statement](/docs/cash-flow-statement) in the Embedded UI.
  * Performance improvements to [Cash Flow Statement](/v5.0/api-reference/reports/cash-flow-statement-direct) generation.

  ### UX Enhancements

  * Updates to block Embedded UI screens based on users’ [available features](/docs/creating-a-user).

  ### Unit Integration

  * Improvements to [Unit](/docs/unit-integration) transaction parsing for more detailed descriptions on transactions.

  ### BI Tiles

  * Enhancements to the [Cash Flow tile](/docs/business-intelligence#4-cash-flow-tile) to more accurately depict users’ business cash flow and match the Cash Flow Statement.
  * Enhancements to the [Income tile](/docs/business-intelligence#7-income-tile) and [Expense tile](/docs/business-intelligence#6-expense-tile) to include manual journal entries in totals.

  ## Bug Fixes

  * Fixes to the 3-dot pagination loader at the bottom of all transaction-related dashboards.
  * Fixes to loader in the zero state on the [General Ledger dashboard](/docs/general-ledger-component).
  * Updates to the [Expense BI tile](/docs/business-intelligence#6-expense-tile) to only include business expenses.
  * Correction to [Cash Flow Statements](/docs/cash-flow-statement) to correctly include security deposit expenses.
  * Improvement to Attachments API to maintain a single invoice logo per business.
  * Data fix to remove duplicate invoice payments for users that hit a rare duplicate payment bug.
  * Fixes to correctly invoke invoicing payment processor listeners when setting up payment processing directly from the Invoice form.
</Update>

<Update label="July 30, 2024">
  Enhancements to Stripe Integration for improved connection to Hurdlr Invoicing.

  ## New Features/Enhancements

  ### Invoicing

  * Stripe account data can be ingested via [POST /stripeAccountId endpoint](/v5.0/api-reference/invoicing/save-a-stripe-account).
  * More detailed invoice payment data available via [API](/reference/getpayments).
  * Invoices can be sent from the user’s business name instead of their email address.

  ### Accounting

  * Support for recurring journal entries in the Embedded UI and [API](/reference/postmanualjournalentry).

  ### Transactions

  * Ability to split expenses for business-only accounts into business and personal expenses.
  * Update Bank Transfers to include additional metadata in [API](/reference/getbanktransfers).

  ### Embedded UI

  * The ability to [hide animations in the Embedded UI](/docs/next-steps-user-interface#2-customizing-the-embedded-ui-to-match-your-branding).

  ## Bug Fixes

  * Fix to JSON API response format for [Profit & Loss JSON report](/api-reference/reports/profit-and-loss).
  * Fix to Balance Sheet for better handling of suspense accounts.
  * Fixes to Cash Flow Statement to be consistent with other reports.
  * Fixes to bank reconciliations on deleted bank accounts.
  * Fixes to Chart of Accounts aggregate figures.
  * UI fixes on invoice form.
  * Minor display fixes for dates on the General Ledger.
  * Fixes to transaction conversions.
</Update>

<Update label="July 12, 2024">
  Read-only scope for restricted access in the API and Embedded UI along with other enhancements to Invoicing and Bank Transactions

  ## New Features/Enhancements

  ### UX Enhancements

  * User’s role can be set to `READ_ONLY` [via API](/reference/postuserinfo) to restrict the Embedded UI to a read-only view.

  ### Audit Trail

  * Transactions can be audited in the Embedded UI and [via API](https://www.hurdlr.com/reference/auditexpense) to view a revision history for that transaction.

  ### Invoicing

  * Inclusion of invoice payments in the [Transaction](/docs/transactions-dashboard) and [Income](/docs/income-dashboard) Dashboards.
  * Update to invoice picker on the [Transaction](/docs/transactions-dashboard) and [Income](/docs/income-dashboard) Dashboards to include the invoice date.
  * Stripe customer and payment data can be ingested via [POST /payments endpoint](/v5.0/api-reference/invoicing/process-payment).

  ### Transactions

  * [The ability to render a single transaction form overlayed in the partner’s app](/docs/transaction-form).
  * Enhanced matching and categorization of expense refunds.

  ### Reports

  * UI support for pulling partial month Balance Sheets.
  * Ability to generate comparative Trial Balance reports.
  * Performance improvements for the Trial Balance report.

  ### Accounting Migrations

  * Enhanced detection of revenue refunds in accounting imports.
  * Enhancements to [QBO Import](/reference/importqbo) to handle reimbursed expenses.

  ### Bank Reconciliation

  * Bank reconciliations automatically merged when corresponding bank accounts are merged.

  ### Analytics

  * Enhancements to the [Mixpanel](/docs/mixpanel-integration) and [Intercom](/docs/intercom) integrations to accept expanded configurations.

  ## Bug Fixes

  * Fixes to date handling on bank reconciliations.
  * Fixes to drill-down reports.
  * Fixes to Chart of Accounts to ensure correct balances are displayed.
  * Fixes for timezone issues when pulling reports.
  * Minor fixes to Bank Transfer conversions and matching.
  * Update to [Stripe integration](/docs/stripe)  so transactions always have distinct API ids.
</Update>

<Update label="June 14, 2024">
  Enhancements to Tax Estimates, Accounting Migrations, and API performance

  ## New Features/Enhancements

  ### Taxes

  * Prior quarterly tax obligations always roll into the current quarter.
  * Tax estimates displayed even with no business income tracked.

  ### Accounting Migrations

  * Hurdlr [API](/v5.0/api-reference/imports/import-bench) and Embedded UI support for importing users’ data from Bench.
  * Improved ingestion of invoices and invoice payments.

  ### Embedded UI Updates

  * [Routing from the Business Intelligence Tiles](/docs/business-intelligence-tile-components#7-routing-the-tiles) can be defined on a specific set of tiles, allowing partners to still take advantage of Hurdlr’s expandable [Profit and Loss tile](/docs/business-intelligence#3-profit--loss-tile).
  * `options.showAnimations` can be set to `false` to disable animations in the Embedded UI.

  ### API Improvement

  * Addition of `deletedIds` to attachments API.

  ### Performance Enhancements

  * Faster rendering of the Trial Balance report.
  * Performance improvements for loading of the Journal and General Ledger.

  ## Bug Fixes

  * Fixes for rendering the correct balances when flipping between the Profit & Loss and Balance Sheet.
  * Fixes to the General Ledger rendering to ensure all entries are displayed.
  * Fixes so scheduled invoices send on their scheduled date.
  * UX fix for the Plaid [NO\_ACCOUNTS](https://plaid.com/docs/errors/item/#no_accounts) error, so the financial institution can be unlinked in the Embedded UI.
</Update>

<Update label="June 3, 2024">
  Enhancements to Bank Transaction automatic reconciliation and performance on the core Financial Reports.

  ## New Features/Enhancements

  ### Performance Enhancements

  * Balance Sheet and Profit & Loss render 80% quicker (80% less latency).
  * [General Ledger endpoint](/reference/getgeneralledgerentries) responds 15% quicker (15% less latency).

  ### Bank Transfer Matching

  * Bank Transfers can be matched with any transaction of the same amount, which automatically converts to a Bank Transfer.

  ### Accounting Migrations

  * [Xero](/reference/importxero) and [QBO](/reference/importqbo) migrations support importing XLS/XLSX files in addition to prior CSV support.

  ### Accountant Dashboard

  * Accountants can [automatically get access to all users](/v5.0/api-reference/accountant/create-an-accountant) by setting `canAccessAllUsers` to `true`.

  ### Plaid

  * New function added to render [Plaid Link directly over your existing onboarding UI](/docs/plaid-integration#4-plaid-link-new-implementation), removing the need to manually pass Plaid `access_tokens` to the Hurdlr API

  ### Transactions UI

  * The `bankDescription` field will now be displayed when hovering over transaction rows on the transactions and reconciliation dashboards.

  ### Bug Fixes

  * Fixes to `deletedIds` on [GET /generalLedgerEntries](/reference/getgeneralledgerentries).
  * Fixes to CSV Import Completed alert to include counts for bank transfers and tax payments.
  * Fixes to date filtering when drilling down into “Current Income” from Balance Sheet.
  * Removal of Equity/Liabilities income from business income reports.
  * Improved consistency of date-pickers throughout the Embedded UI.
</Update>

<Update label="H1 2024">
  Infrastructure improvements to general ledger, consuming APIs, and monitoring resulting in increased performance (financial reports spanning multiple years generated in milliseconds), robustness (stronger SLAs), and a SOC 2 Type 2 audit completed with zero exceptions. Public exposure of the Audit Trail.
</Update>

<Update label="2023">
  Launch, including iterations with thousands of businesses, of multi-year imports from [QuickBooks Online](/docs/quickbooks-online) and [Xero](/docs/xero)
</Update>

<Update label="2022">
  Launch of dedicated [Accountant Dashboard](/docs/bookkeeper-dashboard), to streamline operations for large Virtual Bookkeeping firms, while keeping the business owner-operator experience simple.
</Update>

<Update label="2021">
  Launch of many [native integrations](/integrations/native-integrations) per customer-partner requests.
</Update>

<Update label="2020">
  First public release of the Embedded UI, for new customer-partners desiring Hurdlr’s proven user experience.
</Update>

<Update label="2019">
  First public release of the Hurdlr API, for the launch of Hurdlr’s first API customer-partner. This release made the Hurdlr API, privately consumed by hundreds of thousands of SMBs by way of the Hurdlr app (lanched in 2015), public for the first time.
</Update>

<Update label="2012-2018">
  Founded in 2012, API development started with the double-entry general ledger with full Audit Trail and then expanded into invoicing, income/expense tracking, financial statements, and income taxes. Learning the “Embedded” space did not yet exist, the Hurdlr app was built and ultimately released in 2015 to showcase the API’s features. The Hurdlr app ultimately grew to hundreds of thousands of small business owners, allowing the API to reach product maturity and cover the many edge cases faced by real users in production. In 2019, Hurdlr received its first organic API lead, realizing its initial API-first product vision.
</Update>


# Roadmap
Source: https://docs.tight.com/roadmap/roadmap

Breakdown of Tight's ongoing high-level priorities and projects.

## Q2 2026

### Agents & MCP

* **Accounting Agent**: [Tight's Accounting Agent](/ai/agentic/agentic-accountant) will summarize of each business',
  financial performance, based
  on [configurable periods](/api-reference/agentic-accounting-settings/get-agentic-accountant-settings)
* **Self-Learning Categorization**: Improved accuracy and coverage of transaction categorization, enabled by an
  AI-powered model
  that [learns from transactions across 1.3M+ SMBs](/ai/categorization/self-learning-transaction-categorization-overview)

### Bank Transactions

* **Rule Engine Enhancements**: More expressive and powerful Rules to classify, categorize, and flag [Bank
  Transactions](/guides/business-owners/bank-transactions) for review
* **Ongoing Bank Balance Checks**: Accounts with balances that are inconsistent with Tight's General Ledger will be
  automatically flagged

### Dimension Tracking and Reporting

* **Integrated Tracking**: Assign hierarchical [dimension](/guides/business-owners/general-ledger#dimension-tracking)
  defined by your
  platform to transactions, invoices, and expenses
* **Report Groups & Filters**:
  Generate [Profit & Loss reports](/embeddable-ui/react/financial-statements/profit-loss-report#profit-and-loss-report)
  segmented by dimension to understand which locations, products, or projects are most profitable

## Q3 2026

### Agents & MCP

* **Bookkeeping and Support Agents**: Introduction
  of [Tight's Bookkeeping Agent and Support Agent](/ai/agentic/agentic-accountant):
  * Bookkeeping Agent: Detects anomalies in transaction data and reaches out to the user with questions to help
    categorize transactions
  * Support Agent: Provides support to users with deep context on their business and how Tight works

### Financial Statements

* **Financial Statement Components**: Refreshed Embedded UI
  for [Balance Sheet](/embeddable-ui/react/financial-statements/balance-sheet),
  [Cash Flow](/embeddable-ui/react/financial-statements/cash-flow-statement), [Profit & Loss](/embeddable-ui/react/financial-statements/profit-loss-report),
  and [Trial Balance](/embeddable-ui/react/financial-statements/trial-balance-report) reports
* **Interactive Drill-Downs**: Click any line item on
  any [financial report](/guides/business-owners/financial-statements#interactive-drill-downs)
  to instantly see the underlying General Ledger entries that compose the figure
* **Report Grouping by Dimension**: Group [financial statements](/guides/business-owners/dimensions) by
  location, product line, project, or department to understand which segments drive profitability

### Invoicing

* **Invoicing Components**: Refreshed Embedded UI for Invoicing pages, dashboards, and individual components
* **Invoice Line Item Templates**: Create and customize reusable Invoice Line Item Templates
* **Payment Installments**: Enable customers to pay invoices in multiple installments according to a predefined schedule
* **Invoice Advanced Search and Improved Sorting**: Improved filtering and sorting on the Invoicing Dashboard

### Accounting

* **Accounting Components**: Refreshed Embedded UI for Accounting pages, dashboards, and individual components

## Q4 2026

### Agents & MCP

* **Finance and Accounting Agents**: Introduction of the [Tight CFO Agent](/ai/agentic/agentic-accountant) and updates
  to the Accounting Agent:
  * Tight CFO Agent: Provides trend analysis and spend management guidance to business owners on all of their
    historical data
  * Tight Accounting Agent: New ability to perform bank statement reconciliations
* **Two-way Conversations via SMS**: Enable agents to request needed information directly from users via text message
  conversations

### Bill Pay (A/P)

* **Bill Components**: New Embedded UI for Bill pages, dashboards, and individual components, built on Tight's proven
  [Bills API](/api-reference/bills/query-bills)
* **Bill Payment Processing**: Automate recurring bill payments by sending money to vendors

### Accountant

* **Multi-Client Business Breakdown**: Provide a business-by-business view for accountants who support multiple clients
* **Closings Management**: Review all closings across businesses and insert pending reconciliations on
  the day of month specified by the customer partner
* **Connections Management**: Review all linked bank accounts and connection statuses, run real-time balance
  confirmations
  to flag issues early, and surface institution-level connection outages
* **Transactions Management**: Review all transactions across businesses and filter transactions by review status
* **Comprehensive Audit Trail**: Review the Audit Trail across businesses and filter by business, accountant, and other
  dimensions for faster auditing

### Audit Trail

* **Audit Trail Components**: Refreshed Embedded UI for Audit Trail pages, dashboards, and individual components
* **User-Level Audit Trail**: View of the Audit Trail at the user level, useful for auditing actions made by specific
  accountants or users across all entities

## Q1 2027

### Accounting

* **Revenue Recognition Schedule**: Simplified entities for revenue recognition schedules, minimizing the need for
  recurring journal entries
* **Asset Depreciation Schedule**: Simplified entities for depreciation schedules, minimizing the need for
  recurring journal entries
* **Expense Amortization Schedule**: Simplified entities for expense amortization schedules, minimizing the need for
  recurring journal entries

### Integrations

* **Parafin Integration**: Enhanced Capital integration to simply require key sharing (as opposed to forwarding from
  Tight Data Lakes)
* **CapitalOS Integration**: Enhanced Capital integration to simply require key sharing (as opposed to forwarding from
  Tight Data Lakes)
* **Pipe Integration**: Enhanced Capital integration to simply require key sharing (as opposed to forwarding from Tight
  Data Lakes)
* **Salsa Payroll Integration**: Native integration with Salsa embedded payroll platform

### Invoicing

* **Multiple Invoice Templates**: Support for multiple, selectable Invoice Templates
* **Improved Quotes**: Functionality around clients accepting or rejecting quotes, including expiration dates
* **Google Pay / Apple Pay for Invoice Payments**: Integrating Google Pay / Apple Pay for Client Invoice Payments


# Releases
Source: https://docs.tight.com/roadmap/releases



<Update label="September 29, 2026" description="v6.10.9">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * Agents can now tailor a business's chart of accounts via MCP by adding and editing its
    [General Ledger accounts](/api-reference/gl-accounts/save-gl-accounts).

  ## **Existing v5 Features Upgraded to v6**

  ### Bank Transactions

  * Searching or filtering [bank transactions](/api-reference/bank-transactions/query-transactions) now returns a split
    transaction when any of its line items match.

  ### Embedded UI

  * You can now restyle the empty-state call-to-action buttons in the v6 embedded UI with new
    [design tokens](/embeddable-ui/react/reference/design-tokens).

  ## **Fixes**

  ### Bank Transactions

  * Users can now pick accounts imported from another accounting platform, such as QuickBooks Online, when merging
    duplicates into a linked account in [Banks & Integrations](/embeddable-ui/react/banks-and-integrations).
  * [Bank statements](/api-reference/bank-statements/query-bank-statements) now download soon after Plaid finishes
    refreshing them, rather than waiting behind a backlog of transaction updates.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="September 15, 2026" description="v6.10.8">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * Agents can now create and manage [payroll](/api-reference/payroll/query-payroll) entries via MCP.

  ## **Existing v5 Features Upgraded to v6**

  ### Payroll

  * When a [bank transaction](/api-reference/bank-transactions/query-transactions) is linked to a payroll, expanding
    the payroll now returns the individual line items the transaction is linked to.

  ### Bank Transactions

  * Tax payments now appear as an expense category in the
    [transaction form](/embeddable-ui/react/bank-transactions/transaction-form), instead of a separate type.

  ## **Fixes**

  ### Reports

  * Drilling from Net Income on the [Cash Flow Statement](/embeddable-ui/react/financial-statements/cash-flow-statement)
    into the [Profit & Loss report](/embeddable-ui/react/financial-statements/profit-loss-report) now carries the
    report's customer and dimension filters and grouping.
  * A [Balance Sheet](/api-reference/reports/balance-sheet) now exports to CSV successfully when an account's balance
    is above \$21 million.

  ### Integrations

  * QuickBooks: [imports](/embeddable-ui/react/imports/quickbooks-online-import) now record bill payments made by
    credit card as bill payments rather than manual journal entries.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="September 1, 2026" description="v6.10.7">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * Agents can now create and manage [categorization rules](/api-reference/transaction-rules/save-transaction-rules)
    via MCP, including [partner-level template rules](/api-reference/templates/save-template-rules) that apply across
    every company you manage.

  ## **Existing v5 Features Upgraded to v6**

  ### Payroll

  * Payroll is now available in v6, with [save](/api-reference/payroll/save-payroll),
    [query](/api-reference/payroll/query-payroll), and [get](/api-reference/payroll/get-payroll) operations covering a
    payroll and its line items, such as net pay, employer tax, and employee benefit.

  ### Journal

  * The [`Journal`](/embeddable-ui/react/accounting/journal) component is now available in the v6 embedded UI, where end
    users can review journal entries with their debits and credits.
  * An edit to one occurrence of a recurring
    [manual journal entry](/api-reference/manual-journal-entries/save-manual-journal-entries) can now be applied to
    every later occurrence at once with the new `SINGLE_RECURRENCE_AND_ALL_FUTURE` update type.

  ### General Ledger

  * [General Ledger entries](/api-reference/gl-entries/query-gl-entries) can now be filtered by customer, with the
    beginning and running balances recalculated for the filtered set.

  ### Bank Transactions

  * A [payment](/api-reference/payments/query-payments) or
    [bank transaction](/api-reference/bank-transactions/query-transactions) query can now expand its linked invoice
    with the `apiSourceId` you assigned, so you can match it to your own invoice record without a second lookup.

  ### Embedded UI

  * The [`FinancialOverview`](/embeddable-ui/react/financial-overview) dashboard now opens on the previous month by
    default rather than the current one.

  ## **Fixes**

  ### Reports

  * Specifying `accountingMethod: ACCRUAL` on a [Balance Sheet](/api-reference/reports/balance-sheet) report request
    now returns the correct value for Current Income.
  * Drilling from a report into the [General Ledger](/embeddable-ui/react/accounting/general-ledger) now carries the
    report's dimension and customer filters, and returning by breadcrumb restores the report as it was left.

  ### Bank Transactions

  * A money-in [bank transaction](/api-reference/bank-transactions/query-transactions) categorized to a `SUSPENSE`
    General Ledger account now returns a `type` of `REVENUE` instead of `EXPENSE`.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="August 18, 2026" description="v6.10.6">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * Agents can now read and write[ manual journal entries](/api-reference/manual-journal-entries/save-manual-journal-entries) via MCP.
  * New MCP tooling for building and managing [chart of accounts templates](/api-reference/templates/save-chart-of-accounts-template).
  * The new `generate_one_time_link` MCP tool returns a single-use login link, so an agent can drop a user straight into
    your [Ready-to-Launch](/guides/launch-paths/ready-to-launch) experience.

  ### Authentication

  * Partners using [Ready-to-Launch](/guides/launch-paths/ready-to-launch) can now generate
    [one-time login links](/api-reference/auth/generate-one-time-link) for any of their users, including bookkeepers
    accessing a specific business directly.

  ## **Existing v5 Features Upgraded to v6**

  ### Bank Reconciliation

  * [Bank account queries](/api-reference/bank-accounts/query-bank-accounts) now return each account's reconciliation
    state, including the end date of the most recent completed reconciliation.

  ### Journal

  * [Journal entries](/api-reference/journal/query-journal-entries) now include a `typeDisplayName` alongside the raw
    `type`.

  ## **Fixes**

  ### Bank Transactions

  * [Saving a transaction](/api-reference/bank-transactions/save-transactions) now rejects an `originalCurrency` for
    which no exchange rate is published, such as `MRU` or `MGA`, with a validation error on that field.
  * Creating a [payment](/api-reference/payments/save-payments) with an `apiSourceId` already used on the same bank
    account is now rejected as a duplicate.
  * Choosing "Bank transfer" on a transaction in the embedded
    [transaction form](/embeddable-ui/react/bank-transactions/transaction-form) now returns the matching transactions to
    link against, including transfers already recorded on another account regardless of date.

  ### General Ledger

  * Opening a payment-processor entry in the
    [`GeneralLedger`](/embeddable-ui/react/accounting/general-ledger) component now fires
    `OPEN_PROCESSOR_TRANSACTION_FORM` carrying the payment record, so a listener typed only to a bank transaction needs
    to widen to accept both shapes.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="August 4, 2026" description="v6.10.3">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * New MCP tools for [Bank Statements](/api-reference/bank-statements/query-bank-statements).

  ### Embedded UI

  * Addition of new [design tokens](/embeddable-ui/react/reference/design-tokens) for improved customizability on the
    navigation panel, menu controls, and expense and income overviews.

  ### Bank Transactions

  * Incoming bank transactions now automatically match to processor transactions created through the API, not only
    to processor payouts Tight ingested as part of its [payment processor integrations](/integrations/payment-processing/stripe).

  ## **Existing v5 Features Upgraded to v6**

  ### Embedded UI

  * Transaction form events can now be received through dedicated `bankTransactionForm` and `processorTransactionForm`
    listeners.

  ### Chart of Accounts

  * The [Chart of Accounts](/embeddable-ui/react/accounting/chart-of-accounts) component is now available in the v6
    embedded UI, where end users can manage accounts and drill into the General Ledger from an individual account.

  ### Journal

  * The journal is now available in v6 through `POST /v6/reports/journal/query`, returning every journal entry in date
    order with its debit and credit lines.
  * [Manual journal entries](/api-reference/manual-journal-entries/save-manual-journal-entries) are now live in v6.

  ### Reports

  * [Profit & Loss](/api-reference/reports/profit-and-loss), [Balance Sheet](/api-reference/reports/balance-sheet), and
    [Cash Flow Statement](/api-reference/reports/cash-flow-statement) exports/emails are now available in the v6 embedded UI.
  * The [Trial Balance report](/embeddable-ui/react/financial-statements/trial-balance-report) is now available in the v6
    [`ReportDashboard`](/embeddable-ui/react/financial-statements/report-dashboard) component.

  ### General Ledger

  * The [`GeneralLedger`](/embeddable-ui/react/accounting/general-ledger) component is now available in v6. Use it to search
    ledger entries and recategorize transactions inline.
  * Select any amount in the Balance Sheet and Cash Flow Statement report to drill down to the
    [`GeneralLedger`](/embeddable-ui/react/accounting/general-ledger) component, filtered to the account and date range of
    the selected amount.

  ## **Fixes**

  ### Companies

  * [Company queries](/api-reference/company-management/query-companies) now return a `status` of `ACTIVE` or `INACTIVE`
    on every company.

  ### Bank Transactions

  * Saving a transaction as `TRANSFER_IN` or `TRANSFER_OUT` while removing all of its line items now succeeds instead of
    failing with "Bank Transfers cannot have children".
  * Updating or deleting a payment nested under a parent bank transaction no longer clears its `bankTransaction` link.
  * [Saving a split transaction](/api-reference/bank-transactions/save-transactions) now requires every child to be
    itemized by the same fields, so mixing children with and without a `customerId` or `dimensionValueIds` is rejected.
  * The bank transaction form in the embedded UI now includes an editable Review Status field.
  * [Deleting a payment](/api-reference/payments/delete-payment), or changing its amount or status, is now rejected when
    that payment is matched to a bank transaction.

  ### Reports

  * Suspense account balances, such as "Ask My Client", now appear under Other Expenses on the v6
    [Profit & Loss](/api-reference/reports/profit-and-loss) report and reduce net income, matching v5.

  ### Embedded UI

  * Selecting a status other than Active on the transaction, income, and expense dashboards now filters the list, and
    Active appears as a visible default filter chip rather than being applied invisibly.
  * Opening a transaction from a General Ledger row now fires `OPEN_BANK_TRANSACTION_FORM` with the full transaction in
    `data` instead of `null`.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="July 21, 2026" description="v6.10.0">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * New MCP tools for creating mileage and related entities, dimension values, time tracking, tax profile, transactions in
    bulk, invoices, and payments.

  ### Integrations

  * Integration credential configuration is now live in v6: save credentials for
    [Plaid](/api-reference/integrations/configure-plaid), [Stripe](/api-reference/integrations/configure-stripe), and
    seven other providers directly through the API.
  * Plaid: a new `statementsEnabled` flag on [Plaid credentials](/api-reference/integrations/configure-plaid) turns on
    bank statement syncing; the Statements product must first be enabled for your `client_id` in the Plaid Dashboard.
  * Plaid: Added ability to automatically estimate beginning balances on all synced accounts. Reach out to the Tight team
    to enable this feature.

  ## **Existing v5 Features Upgraded to v6**

  ### General Ledger

  * The [query](/api-reference/gl-accounts/query-gl-accounts) and [save](/api-reference/gl-accounts/save-gl-accounts)
    General Ledger account endpoints are now live in v6, so you can list a company's accounts and create, update, or
    deactivate them.
  * The [General Ledger entries query](/api-reference/gl-entries/query-gl-entries) accepts a new
    `includeBeginningBalance` flag to request a beginning balance for non-balance-sheet accounts; balance sheet accounts
    include one automatically.

  ## **Fixes**

  ### Bank Transactions

  * Inserting a transaction line item with an `apiItemId` that already exists in the company now returns a validation
    error instead of a generic exception.
  * Line items on a split transaction can now be assigned personal (`EQUITY`-type) General Ledger accounts, which were
    previously rejected as transfer accounts.
  * Updating a payment transaction that came no longer clears its `apiProcessorPayoutId`; the transaction stays linked to
    its payout.

  ### Vendors

  * Syncing bank transactions no longer creates duplicate vendors when a matching vendor already exists, even one that is
    inactive or was removed; the existing vendor is reused and is reactivated when tagged to an expense transaction.

  ### Integrations

  * Adyen: outgoing internal transfers on an Adyen balance platform account are now recorded as expense transactions.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="July 7, 2026" description="v6.9.0">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * The [`query_bank_transactions`](https://docs.tight.com/ai/mcp-tools/bank-transactions-mcp#query-bank-transactions)
    MCP tool now supports cursor pagination and an `lastUpdatedDatetime` filter, and `update_bank_transaction` now enables
    manually matching transfers and refunds.

  ### Conversations

  * [Conversations](/api-reference/conversations/save-conversations) now support a `DRAFT` `resolutionStatus`; messages
    added to a draft conversation are not visible to the business owner until the conversation is finalized.

  ### General Ledger

  * The [General Ledger entries query](/api-reference/gl-entries/query-gl-entries) now accepts a `dimensionValues`
    filter, with running balances computed within the filtered set.

  ### Embedded UI

  * Transaction form events are now delivered through a single `transactionForm` listener in
    `useEmbeddedEventListeners`.
  * Dimension filter and group-by controls on the Profit & Loss report in the
    [`ReportDashboard`](/embeddable-ui/react/financial-statements/report-dashboard) component are now enabled for all
    partners.
  * Keyboard navigation is improved across [embedded components](/embeddable-ui/tight-embeddable-ui): transactions
    dashboard rows can be focused with Tab and opened with Enter or Space, and form fields, including the vendor and
    customer selectors, are now reachable with Tab.

  ## **Existing v5 Features Upgraded to v6**

  ### Embedded UI

  * The [Balance Sheet](/api-reference/reports/balance-sheet) and
    [Cash Flow Statement](/api-reference/reports/cash-flow-statement) reports are now available in the
    [`ReportDashboard`](/embeddable-ui/react/financial-statements/report-dashboard) component alongside Profit & Loss.

  ### General Ledger

  * [General Ledger entries](/api-reference/gl-entries/query-gl-entries) now return the full General Ledger account
    object on each entry and an `entity.secondaryDisplayName` that contains a secondary description of a transaction: for
    bank transaction: the bank account, for invoices: the customer, for bills: the vendor.

  ## **Fixes**

  ### Bank Transactions

  * Unsplitting a transaction (removing all of its child line items) no longer leaves it reported as a split parent
    transaction.
  * Instant or manual payouts from a connected payment processor now match to the corresponding bank transaction and
    categorize automatically, instead of remaining unmatched.

  ### Vendors

  * Saving a vendor that conflicts with an existing vendor now returns a `409` error suggesting merging duplicate
    vendors, instead of a generic concurrent-request message.

  ### Integrations

  * QuickBooks: migrations now import beginning balances for accounts nested at any depth in the balance sheet;
    accounts more than five levels deep were previously skipped.
  * Unit: bank accounts reopened on Unit's side are now reactivated automatically during sync, accounts closed in Unit
    are marked removed, and accounts a user manually deactivated stay inactive.
  * Plaid: [integrations](/api-reference/integration-management/query-integrations) now include an
    `additionalConsentRequired` flag indicating when a bank connection needs re-consent to keep syncing, and embedded
    components show a "Relink for Statements" badge that launches the Plaid re-consent flow, matching v5.
  * Adyen: bank payouts are always recorded as withdrawal transactions on the user's Adyen account even when a matching
    bank transaction is not in the system

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="June 23, 2026" description="v6.8.0">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * The `update_bank_transaction` [MCP tool](https://docs.tight.com/ai/mcp-tools/bank-transactions-mcp#update-bank-transaction)
    can now split a transaction into child line items, and `query_bank_transactions` output distinguishes parent rows
    from child rows.

  ## **Existing v5 Features Upgraded to v6**

  ### General Ledger

  * The [General Ledger entries query](/api-reference/gl-entries/query-gl-entries) now supports a free-text `search`
    across an entry's description, date, and amount, returns a `type` for each entry (such as `EXPENSE`, `REVENUE`,
    `TRANSFER_IN`, or `JOURNAL_ENTRY`), and includes a `beginningBalance` for balance sheet accounts.

  ### Bank Statements

  * The v6 [bank statements query API](/api-reference/bank-statements/query-bank-statements) is now live, returning
    uploaded bank statements with their `status`, a download `url`, and the statement `period`, filterable by bank
    account.

  ### Embedded UI

  * [Embedded components](/embeddable-ui/tight-embeddable-ui) now emit events for actions such as linking a bank through
    Plaid or opening a form, which your application can handle through the new `useEmbeddedEventListeners` hook, with an
    optional `preventDefault` flag to suppress the component's built-in behavior.
  * Saving, updating, or deleting a record now gives clearer feedback; a toast notification confirms success or surfaces
    an error when it completes.

  ## **Fixes**

  ### Bank Transactions

  * Searching transactions by text containing characters outside the Latin-1 set no longer fails the request.

  ### Companies

  * [Creating or updating a company](/api-reference/company-management/create-a-company) now validates the nested
    `address`, including phone number format; addresses that previously passed without validation may now be rejected.
  * Retrieving a company no longer returns an error when there is more than one user associated with the company.

  ### Webhooks

  * Outgoing [webhook](/api-reference/webhooks) payloads larger than 4,500 characters are no longer truncated; the full
    payload is now delivered.

  ### Embedded UI

  * Fixed an issue in Chrome where opening a conversation attached to a transaction would move off the screen.

  ### Integrations

  * Stripe: a charge that is also recorded as a Plaid bank transaction no longer fails to reconcile when the bank
    transaction is processed before the charge; the charge is matched to the existing transaction instead of creating a
    duplicate.
  * QuickBooks: chart of accounts imports now handle account names containing commas, deeply nested sub-accounts, and
    accounts identified by number.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="June 9, 2026" description="v6.7.0">
  ## **New Features & Enhancements**

  ### Agents & MCP

  * The MCP server now includes tools for querying and saving vendors and customers.

  ### Companies

  * The [bank transaction query](/api-reference/bank-transactions/query-transactions) and summary endpoints now accept a
    `company` filter to return transactions for a specific set of companies (up to five) in accountant and partner
    sessions.

  ### Embedded UI

  * Transaction review status names have been updated to be more clear, and relevant to the user's role. Business owners
    and bookkeepers each see statuses relevant to their workflows.

  ## **Existing v5 Features Upgraded to v6**

  ### Reports

  * All report API responses now return monetary amounts as integer cents (for example, `5000` rather than `50.00`);
    margin percentages remain decimal values.
  * Reports now support a `NONE` date grouping that returns a single total for the full reporting period without breaking
    it out by month or quarter.

  ### Embedded UI

  * The [`ReportDashboard`](/embeddable-ui/react/financial-statements/report-dashboard) component is now available in the
    v6 React component library. It includes the new v6 Profit & Loss report, with placeholders for forthcoming v6 reports.

  ### Bank Accounts

  * The [bank accounts query](/api-reference/bank-accounts/query-bank-accounts) endpoint now accepts an `apiName` filter
    to return only accounts from a specific source, such as `PLAID` or `MANUAL_ENTRY`.

  ### Bank Transactions

  * [Saving a bank transaction](/api-reference/bank-transactions/save-transactions) now enforces additional validations:
    the assigned General Ledger account must be a leaf account (an account with no sub-accounts), line items cannot use a
    bank-transfer account, and any referenced vendor must be active.

  ### General Ledger

  * Querying [General Ledger entries](/api-reference/gl-entries/query-gl-entries) is now live in v6, returning each
    entry's account, debit and credit amounts, and a running balance, with date-range, account, and accounting-method
    (accrual or cash) filters.

  ### Integrations

  * Payabli: Payabli invoice payments and refunds now sync automatically.
  * Plaid: synced accounts are now matched by their exact account ID before falling back to the persistent account ID,
    reducing cases where transactions were linked to the wrong bank account.
  * QuickBooks: CSV imports now recognize a `Description` column header, and imports no longer fail when an invoice has no
    associated payment.

  ## **Fixes**

  ### Embedded UI

  * Payment processor accounts (such as Stripe) no longer appear on the bank account card on transaction dashboards; they
    remain available under Banks & Integrations.
  * The sender column in the conversations list now populates correctly.
  * Over- and underpayment warnings on invoice line items are now legible on dark backgrounds.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="May 28, 2026" description="v6.6.0">
  ## **New Features & Enhancements**

  ### Authorization

  * Read-only access tokens are now available; they retain full read access, are rejected on write endpoints.

  ### Bank Transactions

  * Bank transactions now support foreign currency in v6: [save](/api-reference/bank-transactions/save-transactions) accepts an
    `originalCurrency`, and [responses](/api-reference/bank-transactions/query-transactions) include a `currencyInfo`
    object with `originalCurrency`, `originalAmount`, and `exchangeDate`.
  * Transaction dashboards now use a responsive card header (review status, bank account, and chart) that collapses to a
    single column on narrow screens.

  ### Dimensions

  * Dimension hierarchies are now limited to three levels, and bank transactions and payments accept a maximum of four
    dimension values each.

  ## **Existing v5 Features Upgraded to v6**

  ### Taxes

  * Canadian GST, HST, PST, and QST sales taxes are now auto-calculated and
    [General Ledger account](/api-reference/gl-accounts/query-gl-accounts) responses include a `taxCategory` field on
    expense accounts.

  ### Customers

  * Query, save, get, and delete endpoints for the [customers](/api-reference/customers/query-customers) API (formerly
    clients in v5) are now live in v6, with search by name and email on the query endpoint.

  ### General Ledger Accounts

  * The [get](/api-reference/gl-accounts/get-gl-account) and [delete](/api-reference/gl-accounts/delete-gl-account)
    General Ledger account endpoints are now live in v6.

  ### Reports

  * The [Profit & Loss](/api-reference/reports/profit-and-loss) report is now included in v6 Components. Users can
    generate P\&L reports on both an accrual or cash basis with filtering and grouping by dimension.
  * The [Trial Balance](/api-reference/reports/trial-balance) report API is now live in v6.
  * [Profit & Loss](/api-reference/reports/profit-and-loss) responses now include the grouping entity, such as a
    dimension, when results are grouped.
  * The [Profit & Loss](/api-reference/reports/profit-and-loss), [Balance Sheet](/api-reference/reports/balance-sheet),
    [Trial Balance](/api-reference/reports/trial-balance), and
    [Cash Flow Statement](/api-reference/reports/cash-flow-statement) report APIs now accept an empty request body,
    defaulting the reporting period.

  ### Companies

  * The [company query](/api-reference/company-management/query-companies) endpoint is now live in v6, returning the
    companies accessible to an accountant or partner token.

  ### Bank Transactions

  * [Bank transaction](/api-reference/bank-transactions/query-transactions) responses now include a `company` object for
    accountant and partner sessions, identifying the owning company in cross-company queries.
  * `lastUpdatedDateTime` is now returned in [bank transaction](/api-reference/bank-transactions/query-transactions)
    responses.
  * `subType` (for example, `CHECKING`) is now returned in bank account responses, matching v5.
  * Users can now manage vendors and customers in the new v6 transaction settings menu.

  ### Integrations

  * Payabli: new payment processing integration that syncs Payabli charges, payouts, and transfers as bank transactions.
  * Plaid: relinking a bank connection no longer re-imports transactions that were already synced, preventing duplicates.
  * Qualpay: activation now submits the complete tax identification and bank account details required to enable the
    processor.

  ## **Fixes**

  ### Embedded UI

  * On the [`FinancialOverview`](/embeddable-ui/react/financial-overview) dashboard, DIY (do-it-yourself) companies no
    longer see the Conversations, Financial Summary, and Message Bookkeeper sections.
  * Category and account SVG icons now properly support theme customization.
  * Default filters have been standardized across all transactions dashboards and tables.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="May 12, 2026" description="v6.5.0">
  ## **New Features & Enhancements**

  ### Reports

  * The recently upgraded v6 Balance Sheet report supports filtering and grouping by dimension, enabling
    multi-dimensional, end-to-end [dimension values](/guides/business-owners/dimensions) on any labels you define through
    the dimension labels API.

  ## **Existing v5 Features Upgraded to v6**

  ### Payments

  * The [save](/api-reference/payments/save-payments), [query](/api-reference/payments/query-payments),
    [get](/api-reference/payments/get-payment), and [delete](/api-reference/payments/delete-payment) payment endpoints are
    now live. Payment IDs use the `ptxn_` prefix and child line item IDs use the `tli_` prefix; `date`, `amount`, and
    `description` are required on save.

  ### Reports

  * The [Balance Sheet](/api-reference/reports/balance-sheet) report API is now live in v6.

  ### Bank Transactions

  * [Save bank transactions](/api-reference/bank-transactions/save-transactions) now accepts
    [payments](/api-reference/payments/save-payments) as children. `paymentId` field added to
    [bank transaction](/api-reference/bank-transactions/query-transactions) child responses, identifying the linked
    payment.

  ### Bills

  * [Bills query](/api-reference/bills/query-bills) now supports a `billStatus` filter with `in` and `notIn` arrays,
    alongside the existing `status` filter.

  ### Companies

  * `phoneWork` on [company addresses](/api-reference/company-management/create-a-company) is now restricted to US and
    Canada [E.164](https://www.itu.int/rec/T-REC-E.164) format. International numbers outside of US and Canada will be
    rejected.

  ### Embedded UI

  * New payment selector on v6 [bank transaction forms](/embeddable-ui/react/bank-transactions/transaction-form) lets
    users link [payments](/api-reference/payments/save-payments) (e.g., Stripe charges) to a parent bank transaction
    (e.g., a payout). Drawer-based selection includes search, filters, and total validation.
  * Overpaid and Underpaid status labels added to invoice and bill line item sections on bank transaction forms, surfacing
    mismatches between the transaction amount and linked line item totals.
  * Review status display now shows role-specific labels: accountants see Discrepancy, Client Review, Needs Review, and
    Staged; business owners see Needs Review, Discrepancy, Processing, and Reconciled.

  ### Integrations

  * Plaid: bank sync now backfills any transactions missed by the standard sync within the configured date range.
  * Gusto and Check: payroll expense matching now uses provider-specific logic. Gusto matches across all payroll fields
    including benefits, while Check matches only the total debit amount.

  ## **Fixes**

  ### Embedded UI

  * Tab key now traverses all form fields including date picker months and stays trapped within drawer forms.

  ### Bank Transactions

  * Queries with enum-valued status filters (such as `reviewStatus`) on
    [bank transactions](/api-reference/bank-transactions/query-transactions) now return the correct rows.
  * [Save bank transactions](/api-reference/bank-transactions/save-transactions) no longer accepts new transactions that
    are not Active.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="April 28, 2026" description="v6.4.0">
  ## **New Features & Enhancements**

  ### Webhooks

  * New [`bankNotLinkedAfterOnboarding`](/api-reference/webhooks) webhook event fires when a company completes onboarding
    without linking a bank account.

  ### Embedded UI

  * New `TightApp` component wraps multi-page embedded experiences with built-in navigation, drawer state tracking, and
    anchor scrolling.

  ### Companies

  * `phoneWork` on [address](/api-reference/company-management/create-a-company) now requires
    [E.164 format](https://www.itu.int/rec/T-REC-E.164) (e.g., `+14155551234`). v5 did not enforce this format, so
    payloads accepted by v5 may need to be reformatted before they pass v6 validation.

  ## **Existing v5 Features Upgraded to v6**

  ### Bank Transactions

  * [Bank transactions](/api-reference/bank-transactions/query-transactions) filter `lastUpdatedDate` renamed to
    `lastUpdatedDateTime` and now publicly documented.
  * `amount` field on [bank transaction](/api-reference/bank-transactions/save-transactions) child line items is no longer
    required.

  ### Invoicing

  * [Invoices query](/api-reference/invoicing--invoices/query-invoices) endpoint now supports an `invoiceStatus` filter
    with `in` and `notIn` arrays. The existing `status` filter is retained.

  ### Embedded UI

  * The alert component now uses a responsive layout.

  ### Integrations

  * Stripe: balance transactions with `financing_paydown` reporting category now categorize to the Loan Payable expense
    category.

  ## **Fixes**

  ### Embedded UI

  * Table rows no longer overflow their parent container on hover.
  * Bank account rows no longer show "Processing" sub-text after the first sync completes; the label is now scoped to
    accounts that have `syncTransactions` enabled but no `lastSyncedDate`, and "Not Synced" is scoped to accounts with
    `syncTransactions` disabled.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="April 14, 2026" description="v6.3.0">
  ## **New Features & Enhancements**

  ### Dimensions

  * Dimension values now enforce parent-child hierarchy validation, automatically inferring the parent when a child
    dimension value is provided.
  * `child` field on a dimension is now nullable, supporting leaf-level dimensions without children.

  ### Embedded UI

  * Cash Flow and Expense tiles on the [Business Owner Dashboard](/embeddable-ui/react/financial-overview) now
    display month-over-month comparison chips.
  * [Business Owner Dashboard](/embeddable-ui/react/financial-overview) transaction section now renders on mobile
    with search and review capabilities.

  ## **Existing v5 Features Upgraded to v6**

  ### Bank Transactions

  * [Bank transaction](/api-reference/bank-transactions/query-transactions) `type` field simplified to four public values:
    `EXPENSE`, `REVENUE`, `TRANSFER_IN`, `TRANSFER_OUT`. Endpoints still accept previous values via version negotiation.
  * `reviewStatus` values consolidated. Endpoints still accept previous values via version negotiation.
  * `vendor` field on [bank transaction](/api-reference/bank-transactions/query-transactions) responses now returned only
    on expense-type transactions.
  * ID format validation now enforced on reference fields (`customerId`, `categoryId`, `glAccountId`, `invoiceId`,
    `billId`, `payrollId`) when [saving transactions](/api-reference/bank-transactions/save-transactions).
  * Maximum attachment count validation now enforced on
    [bank transaction](/api-reference/bank-transactions/save-transactions) save operations.

  ### Bills

  * [Bills query](/api-reference/bills/query-bills) endpoint now supports `search` filter and `DATE_PROXIMITY` sort
    option.

  ### Invoicing

  * [Invoices query](/api-reference/invoicing--invoices/query-invoices) endpoint now available in v6 with `search` filter
    and `DATE_PROXIMITY` sort option.

  ### Payroll

  * [Payroll query](/api-reference/payroll/query-payroll) endpoint now available in v6 with `search` filter. `amount`
    field type widened from `Integer` to `Long`.

  ### Customers

  * [Customer query](/api-reference/customers/query-customers) endpoint now supports `email` filter and `EMAIL` sort
    option. `createdDateTime` field added to the response.

  ### Embedded UI

  * Drag-and-drop attachment support now available on
    [bank transaction forms](/embeddable-ui/react/bank-transactions/transaction-form).
  * Customer selection modal with search and inline create added to bank transaction forms.
  * Radio button indicators now display on single-select filter lists across dashboards.
  * [Expense Dashboard](/embeddable-ui/react/bank-transactions/expense-dashboard) and
    [Income Dashboard](/embeddable-ui/react/bank-transactions/income-dashboard) now available as standalone component
    exports.
  * Bank transaction form now submits only modified fields, reducing unnecessary writes.

  ## **Fixes**

  ### Bank Transactions

  * Fixed revenue and expense validation when itemizing transactions.
  * Fixed parent dimension value form validation on bank transaction forms.
  * Fixed API error in [bank transaction summary](/api-reference/bank-transactions/query-transactions) when `groupBy`
    parameter is omitted.

  ### Embedded UI

  * Dashboard charts now update when transactions change and no longer query removed bank accounts.

  ### Webhooks

  * Fixed persistence of non-latin1 characters in outgoing [webhook](/api-reference/webhooks) payloads.

  ### API

  * Standardized error response for requests with missing request body.
  * List filter parameters no longer cause errors when containing null values.

  See the [v5 release notes](/roadmap/v5/releases) for changes specific to v5.
</Update>

<Update label="March 31, 2026" description="v6.2.0">
  ## **New Features/Enhancements**

  ### *Bank Transactions*

  * Introduction of the [Expense](/embeddable-ui/react/bank-transactions/expense-dashboard) and [Income](/embeddable-ui/react/bank-transactions/income-dashboard) Dashboards in React Components.
  * Ability to configure support for multi-dimensional transaction itemization, allowing end users to itemize transactions by customer and class segments such as location and department.
  * Support for attaching invoices and bills to [bank transactions in v6 API](/api-reference/bank-transactions/save-transactions).
  * Refactor to the `type` field on [bank transactions](/api-reference/bank-transactions/query-transactions) to introduce more granularity for display and filtering purposes.

  ### *Data Lakes*

  * New column for lastUpdatedDate on General Ledger entry transactions.
  * Added v6 IDs to transaction and lifecycle event data lake exports.
  * Inclusion of deleted and unlinked bank accounts in data lake exports.
  * Introduction of General Ledger Audit Trail in the Data Lakes.

  ## **Bug Fixes**

  ### *Invoicing*

  * Fix issue preventing cancellation of recurring invoices in the embedded UI.
  * The address field is now optional during tax filing.
  * Fix for duplicate transactions appearing in Money In after removing a matched payout from an invoice.

  ### *API*

  * Fix to 207 multi-status responses incorrectly returning 500 errors when an exception is thrown after validation passes.
  * Fix to GL account ID resolution errors when querying transactions via v6 endpoints.
  * Fix to include v6 revisions in the v5 Audit Trail API.
</Update>

<Update label="March 18, 2026" description="v6.1.0">
  ## **New Features/Enhancements**

  ### *Tax Updates*

  * Updated 2026 Canada federal and provincial tax tables and 2025 US state tax constants to reflect the latest rates and brackets.

  ### *Data Lakes*

  * New User Information data type (reflects [GET /userInfo](https://docs.tight.com/reference/getuserinfo))
  * New User Tax Profile data type (reflects [GET /userTaxSetup](https://docs.tight.com/reference/getusertaxsetup))
  * New Integrations data type (reflects [GET /integrations](https://docs.tight.com/reference/getintegrations))
  * New Time Entries data type (reflects [GET /times](https://docs.tight.com/reference/gettimes))
  * New columns for Bank Transactions: `bankTransferId` and `isPayout`

  ### *Integrations*

  * Update to Plaid integration to update vendor information if modified after the transaction has already been posted.

  ### *API*

  * V5 lifecycle event webhooks now include v6 entity IDs alongside v5 IDs, to better support the migration to v6.
  * New DELETE /v6/company/ endpoint with `ENTITY_UPDATE` webhook for company status tracking.
  * Updates to Year-End Closing logic to mark all transactions in a closed year as `RECONCILED`.

  ### *Imports*

  * Xero imports now pull client details, including  email, address, and phone number in addition to client name, for both new and existing Xero-connected users.

  ## **Bug Fixes**

  ### *Transactions*

  * Revenue Rules created from transactions by a user are no longer being created in a  'Suggested' state.
  * Improved General Ledger entry creation for Bank Transfers where the two sides fall in different months.
  * Bug fix on the Income and Expenses Dashboards to correct search for a figure ending in zero.

  ### *Reports*

  * Tax Report discrepancy fix caused by invoice sales tax being included as income in the Tax Details report.
  * Fix to Business Revenue Report to only show invoice payments associated with the filtered businesses.
  * Exception fix on Balance Sheet Report fix to render all data in totals/balances

  ### *Invoicing*

  * API Fix where `dueDate` was not defined when the invoice term was set to `OTHER`, causing errors when finalizing the invoice.
</Update>

<Update label="March 5, 2026">
  Tight MCP server and bug fixes.

  ## **New Features/Enhancements**

  ### *MCP*

  Tight’s MCP server is launched in sandbox and production. Please reach out for access.

  * Release of Financial Statements MCP tools that support generating, analyzing, and drilling down into the core financial statements: Profit & Loss, Cash Flow Statement, and Balance Sheet.
  * Release of Bank Transaction MCP tools that support reviewing, updating, and summarizing bank transaction data.

  ### *API*

  * Added ability to create parent General Ledger accounts for more advanced CoA customization.

  ### *CSV Imports*

  * Increased the maximum transaction upload limit from 500 to 2,500 transactions during CSV upload.

  ## **Bug Fixes**

  ### *API*

  * Fix when pulling Plaid institution data into Tight SDK caused by a CORS error.

  ### *Bank Transactions*

  * Bug fix to enable converting Stripe bank transfers to revenue.
  * Update to pull bank transaction data when a deleted bank account is restored.
  * Prevention of potential duplicate transactions after attaching a deposit to an invoice and subsequently moving the `tranStartDate` forward on the associated bank account.

  ### *Embedded UI*

  * Fix to SDK’s `renderAccountantUserScreen` when switching between accountant users programmatically.
</Update>

<Update label="February 19, 2026">
  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent.

  ## **New Features/Enhancements**

  ### Plaid

  * Enhancement to trigger a manual pull as a redundancy measure for any Plaid items that haven’t received a webhook for three days.

  ## **Bug Fixes**

  * Fixes when converting Stripe bank transfers to other transaction types.
</Update>

<Update label="February 5, 2026">
  Data Lake enhancements and bug fixes.

  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent.

  ## **Data Lakes Enhancements**

  * Updates to Bank Transactions Data Lakes to include pertinent General Ledger accounts for all transactions.
  * Addition of General Ledger and Chart of Accounts to Data Lakes.

  ## **Bug Fixes**

  * Idempotency fix to [DELETE /v5/expenses/expense](https://docs.tight.com/reference/deleteexpense).
  * Fixed invoice validations to allow the removal of payment processor payments that are manually linked to invoices in error.
  * Resolved a bug where draft invoices were incorrectly recorded as Services Income.
</Update>

<Update label="January 22, 2026">
  Tax Form updates, endpoint enhancements, and bug fixes.

  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent.

  ## **New Features/Enhancements**

  * **2025 US Tax Forms**: Updated Form 1040 Schedule C, Form 1065 population, Form 1120-S, and Form 1120 population for 2024 (commonly filed between April and October 2025), accessible through the Taxes Dashboard and via [API](https://www.hurdlr.com/reference/postreport).

  ## **Bug Fixes**

  * Fixed monthly recurring transaction dates by respecting the user’s timezone.
  * Bug fix to recurring invoice links to display the correct invoice PDF.
  * Bug fixes to errors when sending certain Lifecycle events related to monthly closings.
</Update>

<Update label="January 7, 2026">
  Invoice enhancements, updated lifecycle events, and bug fixes

  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent.

  ## **New Features/Enhancements**

  ### Lifecycle Events

  * New lifecycle event for bankStatementIngested for when a Plaid bank statement is ingested.
  * Addition of transactionIds to transaction edit and creation events.

  ### Invoicing

  * Improvements to automatic reconciliation for manual Stripe payouts.
  * Improved auto-matching logic for direct invoice payments against invoice recurrences.
  * Ability to cancel invoices refunded via payment processor via UI.
  * Updated invoice email UI to replace the “Review & Pay” button with “Review” when no payment link is included (e.g for direct payments).

  ## **Bug Fixes**

  * Fixed a bug causing delays to Tight’s asynchronous actions queue.
  * Fix to include invoice identifier on [POST /invoice](https://docs.tight.com/reference/postinvoice) response for newly created invoices.
</Update>

<Update label="December 16, 2025">
  Bug fixes for Invoicing, Data Lakes, and the API.

  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent. Outside of this, Tight is primarily focused on bug fixes.

  ## **Bug Fixes**

  ### Invoicing

  * Fixes to automatic payout reconciliation for manually initiated Stripe payouts.
  * Improvements to the display of CC and BCC emails on invoices.

  ### Data Lakes

  * Population of missing `userID` on `closingCompleted` events.
  * Updates to the `accountingClosingCompleted` event to include the `closedByUserId` field

  ### API

  * Fix to validation of beginning date on monthly closings.
</Update>

<Update label="December 4, 2025">
  Data Lakes updates, accounting import enhancements, and bug fixes

  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent.

  ## **New Features/Enhancements**

  ### Data Lakes

  * **Journal Entries Data Lake**: Addition of journal entries to Data Lakes.
  * **Transactions Data Lake**: Addition of GL account names for revenue transactions to Data Lakes.
  * **Bank Accounts Data Lake**: Addition of `latestTransactionDate`, `latestStatementDate`, `latestCompletedClosingDate`, and `lastWebhookDatetime` for bank accounts to Data Lakes.

  ### Invoicing

  * **Reopen Invoices**: Enhancement to allow the re-opening of canceled invoices, removing the need to duplicate them.

  ### Imports

  * **Xero / QBO:** Update to support very large file sizes for Xero/QBO imports.

  ## **Bug Fixes**

  ### Integrations

  * Compliance updates to hide the email field in Mixpanel events by default.

  ### Reports

  * Fix to prevent reports from being cut off in preview UI.
  * Fix to exclude newly archived invoices from report totals and Profit & Loss calculations.

  ### Invoicing

  * Bug fix to payout-matching for Stripe payouts to prevent double-counting income and ensure accurate reconciliation for Stripe payouts.
</Update>

<Update label="November 5, 2025">
  Bug fixes for invoicing, transactions, reports.

  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent. Outside of this, Tight is primarily focused on bug fixes.

  ## **Bug Fixes**

  ### Invoicing

  * Fix to invoice total calculation enabling users to close invoices when sales tax and discounts are applied.
  * Update to correctly order the consumption of Stripe webhooks to ensure invoice payments are kept up-to-date with the Stripe API.
  * Bug fix to the default invoice template to prioritize the invoice email over the default client email.

  ### Transactions

  * Fix enabling users to split expenses over multiple bills.

  ### Reports

  * Fix to the Expense and Income by Client reports to correctly display 'No Client' for expenses without clients, ensuring the report matches the Transactions Dashboard UI.
</Update>

<Update label="October 16, 2025">
  New Data Lakes, improvements to Bank Transactions, and bug fixes.

  ## **New Features/Enhancements**

  ### Data Lakes

  * **Transactions Data Lake**: Addition of reviewStatus and client information to transactions data lake.
  * **Balance History Data Lake**: New data lake for bank account balance history for Plaid-connected accounts.
  * **Closings Data Lake**: Addition of monthly closings to Data Lakes.
  * **Rules Data Lake**: Addition of expense and income rules to Data Lakes.

  ### Transactions

  * **Unit Integration**: Unit integration updates to improve bank transaction refund matching.
  * **Transactions Logic**: Updates to prevent the removal of invoiced expenses.
  * **Receipt Display**: Updates to receipt logic to show file name if there is no thumbnail for clear distinction of receipts to attach to expenses.

  ## **Bug Fixes**

  ### Accounting

  * Fix to show an alert when creating a new bank reconciliation with a date range that includes an existing Beginning Balance Journal Entry.
  * Resolved an error preventing year-end closing prior to all reconciliations being completed including inactive reconciliations.
  * Added validations to ensure inactive GL Accounts cannot be assigned as revenue accounts for transactions.

  ### Invoicing

  * Fixed an issue where Stripe payments were not properly updating invoice statuses, ensuring invoices now move from “Processing” to the correct “Paid” status once payments are received.
  * Fix to remove duplicate invoice entries in the General Ledger.
  * Correction to automatic reconciliation of direct invoice payments to exclude invoices with processing payments.
  * Bug fix to properly receive webhooks from Stripe for correct invoice payment processing.
  * Fixes to Stripe payout matching based on Stripe webhook data.
</Update>

<Update label="September 25, 2025">
  OBBBA Tax Updates, Data Lake additions, and big fixes.

  ## **New Features/Enhancements**

  ### Taxes

  * **One Big Beautiful Bill Act (OBBBA) 2025 Tax Changes**: Rollout of 2025 tax code changes introduced by the OBBBA, including standard deduction number updates, child tax credit increases, adjustments to the Qualified Business Income Deduction calculation, SALT limitation increases, and added support for tip and overtime deductions.

  ### Data Lakes

  * **Data Lakes Additions**: Bank transaction rules, monthly closings, and a history of bank account balance data are now all available in the [Tight Data Lakes](https://docs.tight.com/docs/data-lakes).

  ### Bills

  * **Partial Bill Payments**: Added support for partial payments, allowing multiple expenses to be applied to a single bill and validating against the remaining balance rather than requiring an exact match.
  * **Bills API Identifier**: New custom identifier on the [POST /bills endpoint](https://docs.tight.com/reference/postbills) allowing external identifiers to be added to Bills.

  ## **Bug Fixes**

  ### API & Embedded UI

  * Added validation on [DELETE /payment](https://docs.tight.com/reference/deletepayment) to validate against the deletion of Stripe card/ACH payments.
  * Bug fix to allow the merging of bank accounts or updating of the start date even when the account requires a relink with Plaid to enable statements.
  * Bug fix to correctly remove all historical transactions [bank account deletion](https://docs.tight.com/reference/deletebankaccount) when `removeAllTransactions` is true.
  * Optimizations to application of [template rules](https://docs.tight.com/reference/postsetupexpenserules) to existing users.
  * Fix to prevent crashes on Vendor UI forms.

  ### Invoicing

  * Fix to properly label Time & Tasks so they no longer show as INVOICED when no longer attached to an invoice.
  * Bug fix to allow the ability to input a full ZIP code in the Business Information section of Invoice Settings.
  * Updates to automatically split long invoice messages onto two pages when they exceed a certain length.
  * Bug fix to automatically create a Stripe customer when a client adds their default billing information to ensure they can be automatically charged.
</Update>

<Update label="September 3, 2025">
  Bug fixes for transactions, and integrations, and invoicing.

  The Tight team is underway on a MCP-first, new major API version and consuming Embedded Components which is where the majority of our product and engineering resources are being spent. Outside of this, Tight is primarily focused on bug fixes.

  ## **Bug Fixes**

  ### Bank Transactions

  * Fixes to update the `tranStartDate` on re-linked Plaid accounts to be the date of the latest transaction from the originally linked account to more precisely prevent duplicates.
  * Bug fixes to correctly set `currencyType` on bank transactions from Plaid, Unit, and other integrations.
  * Bug fixes to bank account merging when there are manual journal entries between the two bank accounts.
  * Fixes to support CSV imports that create matching bank transfers with existing transactions.

  ### Integrations

  * Fixes and improvements to Stripe payout matching related to instant and reversed payouts.
  * Added validations preventing Stripe payments from being bulk deleted on the Income Dashboard, avoiding issues with payments that were already paid, archived, and duplicated for invoices.

  ### Invoicing

  * Bug fix to correctly update GL entries for paid invoices when an item's income account has been updated.
  * Bug fix to allow expenses and time & tasks to be deleted from an invoice and re-attached to other invoices.
  * Updates to properly calculate the invoice total when attaching manual payments to invoices for expenses and/or time entries.
  * Updates to the [/refundInvoice](https://docs.tight.com/reference/postrefundinvoice) endpoint so refunds correctly mark the paymentMethod instead of defaulting to DIRECT.
  * Fix to correct business logo alignment on invoice PDFs.
  * Fix to allow edits to recurring invoices in closed years.
</Update>

<Update label="August 14, 2025">
  Asynchronous CSV imports, improved API validations, and bug fixes.

  ## **New Features/Enhancements**

  ### CSV Imports

  * Enhancement to make CSV imports asynchronous to prevent timeouts with larger files.
  * Addition of a new banner to let users know when a CSV Import is in-progress, failed, or completed.
  * Ability to view results after a CSV Import including the number of successful imports and a list of transactions that failed to import, if applicable.

  ### Invoicing

  * **Scheduled Invoices**: Ability to print scheduled invoices prior to their being finalized.
  * **Invoice Reminders**: Enhancement to send the invoice reminders and scheduled invoices during the day instead of at night, ensuring clients receive invoice reminders during daytime hours.
  * **Direct Payment Matching**: Improvements to direct payment matching including a wider date range and better tie-breaking.
  * **Sales Tax Updates**: Added API validation to restrict discounts to percentages when sales tax is applied at the item level, ensuring accurate tax calculations.

  ### Embedded UI

  * **Tooltips Update**: Addition of tooltips to the Filter and Sync buttons on the Banks & Integrations screen.
  * **Last Synced Update**: Update to display the last attempted data pull time on the "Last Synced" date instead of the last successful pull.
  * **Revenue Rules**: Users can now create revenue rules from any revenue entry in the Embedded Experience.

  ### Webhooks

  * **Integration Error Events**: Updates to the Integration Error lifecycle events to include more API error metadata.

  ### Accounting

  * **Monthly Closing Validations**: Added validations to prevent monthly closings from having overlapping dates for the same bank account.

  ## **Bug Fixes**

  ### API

  * Performance improvements when reconciling bank accounts with many transactions to ensure all transactions are marked as reconciled efficiently.
  * Fixes to correctly return the `apiTransactionId` for bank transfers.

  ### Invoicing

  * Fix to properly display invoice attachments on recurring invoices.
  * Improvements to prevent all changes to a duplicated invoice from being reverted when the ‘Back’ option is selected.

  ### Integrations

  * Improvements to bank account deduplication logic when there have been many unlinks and relinks of the same bank connection.
  * Bug fix to update Rutter transactions to display the underlying integration’s name as the GL account name instead of "Rutter."
  * Improvements to ensure transactions from Unit accounts pull in correctly and match payouts for accurate balances and totals.
  * Bug fix to deactivate Bank Accounts during refresh when Plaid has removed them
  * Fixes to Stripe matching in tie-breaking cases by using both the transaction’s identifier and the underlying source’s identifier.
  * Bug fix to hide the Scheduled Closings feature on the Banks & Integrations screen if Plaid is not linked or bank reconciliations are not enabled.

  ### Transactions

  * Fix to prevent flickering when saving an Expense Rule.
  * Bug fix to allow recurring expenses to be deleted from the general ledger, journal, or balance sheet drilldown.
  * Updates to properly create a revenue entry when auto classify is enabled and a payment is converted to revenue.
  * Ensure matched bank transfers have a status of matched instead of active.
  * Bug fix to set bank account’s transaction pull date as the earliest transaction date during a bank merge.
</Update>

<Update label="July 24, 2025">
  Client contact details on invoices, Unit integration improvements, and V6 transactions summary API.

  ## **New Features/Enhancements**

  ### Invoicing

  * **Client Contact Details**: Expanded client contact details to support storing additional information such as address, phone number, and more.
  * **Stripe Payouts**: Enhancements to Stripe payout matching to better support and reconcile payout reversals.

  ### Integrations

  * **Unit Improvements**: Visual and organizational enhancements to Unit bank accounts in the Embedded UI along with support for setting start dates, pausing transactions, and setting beginning balances.
  * **Stripe Permissions**: Ability for customer partners to block their users from unlinking integrations. Please reach out if you would like to enable this functionality.
  * **Banks & Integrations**: UI improvements to the Banks & Integrations screen including updating icons and expanding the clickable area of each row for better usability.

  ### API

  * **V6 Summary API**: Ability to [summarize bank transaction data](https://docs.tight.com/v6.0/reference/getbanktransactionssummary) in the V6 API.
  * **Closings API**: Addition of a new [POST /closings](https://docs.tight.com/reference/postclosings) endpoint.

  ## **Bug Fixes**

  ### Transactions

  * Updated default expense naming on the General Ledger Dashboard to display the Vendor name instead of "Manual Expense".
  * Bug fix to ensure that all expenses in a recurring series are updated when the bank account is changed.
  * Fixes to not alter the start date on bank account merges to avoid transactions from being removed.
  * Corrected rule matching logic to support transaction description and vendor-based matches, improving rule application on historical transactions.

  ### Accounting

  * Fix to exclude invoice payments and manual journal entries from bank reconciliation when their dates fall outside the reconciliation range.
  * Ability to edit the equity side of a Beginning Balance entry.
  * Corrected logic to ensure beginning balance entries are properly disconnected from bank accounts when those accounts are deleted to allow the modification of that entry.
  * Bug fix to properly save a bank account's Beginning Balance in the "Edit a Bank Account" view.

  ### Integrations

  * Fixes for accurate currency filtering for transactions ingested as part of the Rutter integration.
  * Payroll fixes to display the integration’s name properly on all payroll forms.

  ### Reports

  * Bug fix to support GL exports when descriptions contain multiple line breaks.

  ### Invoicing

  * Added validations to prevent deposits from being automatically matched to recurring parent invoices, ensuring the invoice continues to recur as intended.
  * Fix to properly convert invoice payments back to their original bank transaction once removed from an invoice.
  * Fixed a UI issue where long client names were not displaying properly when adding payments to invoices.
  * Updates to allow the removal of direct Stripe payments from invoices if an incorrect payment is applied.
  * Corrected a bug that triggered the "Update Recurring Invoice" alert when only modifying the associated bank transaction.
</Update>

<Update label="July 2, 2025">
  Bank statements integrated into Closings UX, V6 Bank Transactions query API, and bug fixes.

  ## **New Features/Enhancements**

  ### Integrations

  * **Bank Statements Integration**: Integration with Plaid’s Statements API to allow bookkeepers to pull Bank Statements directly into the Monthly Closing UX.
  * **Rutter**: Ability to programmatically set the minimum transaction date for bank accounts connected with Rutter.
  * **Gusto**: Improved dates on General Ledger entries for Gusto payrolls.

  ### API

  * **V6 Bank Transactions Query API**: Early access to the [V6 Bank Transactions Query API](https://docs.tight.com/v6.0/reference/querybanktransactions).  Note: there is still a possibility for backwards-incompatible changes as the Tight API team finalizes this new API.
  * **Tax Estimates API:** Enhanced detail and additional fields for tax credit calculations on the [tax estimates API](https://docs.tight.com/reference/postgetestimates).
  * **Delete bank account API**: New [DELETE /account API](https://docs.tight.com/reference/deletebankaccount) to provide the option to delete all associated transactions when deleting a specific bank account.
  * **Invoicing API**: Addition of a `salesTaxPercentage` on [invoice line items](https://docs.tight.com/reference/postinvoice), useful for adding percent sales tax on invoices.
  * **Entity Update Webhook:** Updates to send [entity update webhooks](https://docs.tight.com/docs/webhooks#entity_update) upon bank account creation/reactivation.

  ### Transactions

  * **Transaction visibility:** UI update to show the whole transaction description in a tooltip when it is too long to fit on the transaction row.
  * **New Vendor Update**: Update to auto-populate the new vendor field when searching for a vendor.

  ## **Bug Fixes**

  ### Transactions

  * Correction to the Expense Dashboard overview to no longer include recurring parent transactions.
  * API fix to correctly set the review status when tagging deposits as an invoice payment.
  * Fix to properly bulk tag income categories on the Transaction Dashboard.
  * Bug fix for an issue causing bulk deletion of expenses on the Transactions Dashboard to fail.
  * Fixed an issue where pagination was not always correctly shown on the Vendor List.

  ### Accounting

  * Corrections to display the field validation on a bank reconciliation’s start date when in a closed year.
  * Fixes to remove any extra characters in transaction descriptions when downloading the General Ledger report.
  * Fix to allow accountants to search for users on the teammates form.
  * Fix to update the existing beginning balance entry when adding a monthly closing with a start date prior to that beginning balance entry.
  * Corrected validations to prevent overlapping monthly and yearly closings.

  ### Integrations

  * Fix to the Rutter integration for Shopify transactions to improve payout matching.
  * API fix to correctly dedupe bank accounts when a Plaid Item is unlinked and subsequently relinked.

  ### Invoicing

  * Fix to exclude archived/canceled invoices when selecting the next invoice number.
</Update>

<Update label="June 12, 2025">
  Improvements to the Rutter integration, API access to the Aged Accounts reports, and bug fixes.

  ## New Features/Enhancements

  ### Integrations

  * **Rutter Updates:**
    * Enhancements to the Rutter integration to include the order identifier on pertinent bank transactions.
    * Updates to the Rutter integration to exclude transactions that do not match the user's currency.
    * Changes to ingested transactions to exclude the Rutter description and instead display only the underlying integration’s name.
  * **Integrations Endpoint:** Update to the [GET /integrations](https://docs.tight.com/reference/getintegrations) endpoint to support `lastUpdatedDate` and to include additional API fields.
  * **Stripe Update:** Added idempotency to [POST /stripeAccountId](https://docs.tight.com/reference/poststripeaccountid) endpoint.

  ### Reports

  * **Aged Accounts Payable:** Addition of the [Aged Accounts Payable report](https://docs.tight.com/reference/postagedaccountspayable) to the API.
  * **Aged Accounts Receivable:** Addition of the [Aged Accounts Receivable report](https://docs.tight.com/reference/postagedaccountsreceivable) to the API.

  ### Embedded UI

  * **Expense Categories:** Ability to create an expense category directly from the general ledger account form.
  * **Rule Logic:** Improved rule conflict resolution UX when adding a new rule matching archived rules, giving the option to confirm whether to overwrite or delete the original.
  * **Invoice filtering:** Improvements to filtering and sorting algorithms for potential bank transaction payment matches on the invoice form.

  ### Taxes

  * **Tax Setup**: Enhancements to the Manual Filing Jointly tax flow to provide additional context for each field and minor label edits for clarity.
  * **Tax Filing Data:** Introduction of tax filing data to Data Lakes, matching [GET /taxFilings](https://docs.tight.com/reference/gettaxfilings).

  ## Bug Fixes

  ### Bank Transactions

  * API validation fix to require a child category to be used when categorizing expenses.
  * Improvements to correctly load transactions with a trailing zero during a search.
  * Bug fix to show the correct GL account on tax payments on the Transactions Dashboard.
  * Bug fix to ensure matching bank transfers are correctly merged during bank merges.

  ### Accounting

  * UI fixes to the companies drop down on the accountant dashboard.
  * Fix to correctly render older year-end closing entries when opened from the journal.
  * Corrected validation when attempting to create a monthly closing on an unsupported bank account.

  ### Bank Linkage

  * Fix to Plaid relinks to not sync unsupported bank accounts.

  ### API

  * Bug fix to correctly handle invalid JSON requests as client errors instead of server errors.
  * Fixes to [GET /payment](https://docs.tight.com/reference/getpayments) to only include `bankTransferId` when the payment is part of a payout.
</Update>

<Update label="May 22, 2025">
  Enhanced bank linkage flows, improved vendor management, and bug fixes.

  ## New Features/Enhancements

  ### Bank Linkage

  * **Initial Plaid Linkage:**
    * New prompts to merge existing duplicate bank accounts (e.g. from a QBO migration) into newly linked accounts upon initial Plaid bank account linkage.
    * Notification of which newly linked accounts have unsupported account types or sub types upon initial Plaid bank account linkage.
  * **Banks & Integrations list:**
    * Linked bank accounts are now separated by institution, with new institution level actions.
    * Introduction of Synced and Not Synced filters.
  * **Historical Pull:** Ability to pull historical transactions to a specific date at both the institution and the bank account levels.
  * **Beginning Balances:** Ability to set and edit beginning balance entries directly from the bank account form.
  * **Bank Account Merge:** Option to merge duplicate accounts for multiple accounts at once with improved validations to prevent duplicate bank transactions.
  * **GL Account Naming:** Updates to keep GL account names in sync with updates from Plaid.
  * **Mask Limitations**: Fixes for bank accounts whose mask has less than 4 characters.

  ### Vendor Management

  * **Accountant Access**: Accountants now access the Vendor Dashboard for improved vendor management on behalf of users.
  * **Vendor table**: New columns for Default Category and Expense Rules on the Vendor Dashboard to allow for more efficient vendor management.
  * **Vendors API**: New enhancement to allow the ability to search by vendor name on [GET /vendors](https://docs.tight.com/reference/getvendors) endpoint.
  * **Vendor Merge:** UI improvements to the vendor merge workflow for vendors with very long names.

  ### Transactions

  * **Bulk Restoration**: Ability to bulk restore archived transactions on transactions-related dashboards.
  * **Automatic Reconciliation of Direct Invoice Payments:** Improved tie-breaking when automatically reconciling direct invoice payments with invoices including matching on the invoice’s client’s name.
  * **Advanced Search**: Improvement on the Expense Advanced Search to only show GL accounts that have associated expense categories and all bank accounts, including inactive/previously linked banks.

  ### Accounting

  * **Accountant access**: Accountants can now update their user’s business information in the embedded experience.
  * **QBO Import:** Updated context in the QBO Imports ‘Learn More’ section for pulling the correct files.

  ### Analytics

  * **Transaction Events**: Addition of `transactionRecategorized` [lifecycle event](https://docs.tight.com/docs/lifecycle-event-dictionary#transaction-events) for tracking who recategorized which bank transactions.
  * **Invoice Payment Events**: Enhancement to [lifecycle events](https://docs.tight.com/docs/lifecycle-event-dictionary#invoicing-events) for invoice payments to include the source API on invoice payment-related events.

  ## Bug Fixes

  ### Bank Transactions

  * Fix to allow the creation of personal income transactions via direct [API](https://docs.tight.com/reference/postrevenues).
  * Bug fix for Rutter transactions that were being accounted for in the incorrect GL account.
  * Improvements to our CSV parsing algorithms for files with missing or blank columns.

  ### Invoicing

  * Fixes to correctly use the business email set in the invoice settings instead of the account email when sending out invoices.

  ### Embedded UI

  * Fix for the pending total to only include active bank accounts in the Historical Closings graph.
  * UI fix in the Expenses Dashboard to remain on the exact page of transactions even after transaction updates.
  * UI fixes for expenses split between multiple clients.
</Update>

<Update label="May 1, 2025">
  Introduction of the Wave Migration, a new payment processor, and template rules.

  ## New Features/Enhancements

  ### Imports

  * **Wave:** Introduction of accounting migration from Wave in embedded UI and [API](https://docs.tight.com/reference/importwave).
  * **CoA Mapping API**: New [endpoint](https://docs.tight.com/reference/postmappings) for mapping a user's CoA from their legacy accounting system into the Tight API for more complex migrations.

  ### Integrations

  * **Qualpay:** Integration with new payment processor, [Qualpay](https://docs.tight.com/docs/qualpay).
  * **Transaction Sync**: Ability to pause/unpause transaction ingestion for linked Stripe and Unit accounts directly on Banks & Integrations screen.

  ### Analytics

  * **Lifecycle Events**: Added [lifecycle events](https://docs.tight.com/docs/lifecycle-event-dictionary#transaction-events) for transaction rules.

  ### Bank Transactions

  * **Last Synced Date UI**: Bank accounts now reflect their “Last Synced Date” on the Banks & Integrations screen.
  * **Advanced Search**: Ability to filter by status in the advanced search in Expense and Income Dashboards.

  ### Invoicing

  * **Bulk deletion**: Ability to bulk delete invoice payments from transaction dashboards and via [API](https://docs.tight.com/reference/deletepayments).
  * **Recurring Invoice Emails**: Option to toggle automatic emails for future recurring invoices.

  ### Embedded UI

  * **Expense Rule Templates**: Exposed template rules in [API](https://docs.tight.com/reference/getrules) and embedded UI for bookkeepers and users to review.
  * **Monthly Closings**: Updated validation to prevent the creation of monthly closings in closed years.

  ### API

  * **Attachments:** API enhancement to filter [attachments](https://docs.tight.com/reference/getattachments) to a given entity.
  * **Bank Accounts:** Minor [API](https://docs.tight.com/reference/getbankaccounts) update to return the `integrationId` on pertinent bank accounts.

  ## Bug Fixes

  ### API

  * Fixed an issue that prevented manual journal entries from being submitted when line item descriptions were omitted.
  * Resolved a bug that reset a business’s invoice prefix when the field was omitted from API requests.
  * Fixed a bug where bank account changes on recurring expenses were not being properly saved.

  ### Integrations

  * Fixed an error preventing the auto-charge payment method from working with relinked Stripe accounts.
  * Stripe integrations and associated bank accounts are now correctly marked as archived when disconnected.
  * Ensured historical Plaid transactions are consistently pulled, regardless of webhook delivery order.
</Update>

<Update label="April 10, 2025">
  Mileage SDKs, new Analytics events, and other Invoicing & Accounting enhancements.

  ## New Features/Enhancements

  ### Mileage

  * **Native iOS SDK**: [automatic mileage tracking on iOS](https://docs.tight.com/docs/ios-mileage-tracking-sdk) mobile devices.
  * **Native Android SDK**: [automatic mileage tracking on Android](https://docs.tight.com/docs/android-mileage-tracking-sdk) mobile devices.
  * **APIs**: [GET](https://docs.tight.com/reference/getmileages), [POST](https://docs.tight.com/reference/savemileages), or [DELETE](https://docs.tight.com/reference/deletemileage) mileage records (for customer-partners building their own UX).

  ### Analytics

  * **Lifecycle Events**: Expanded Lifecycle [Webhooks](https://docs.tight.com/docs/webhooks) and corresponding [list of events](https://docs.tight.com/docs/lifecycle-event-dictionary). The new events are also available via [Data Lakes](https://docs.tight.com/docs/data-lakes) and the [Mixpanel integration](https://docs.tight.com/docs/mixpanel-integration) should you wish to track this information in aggregate.
    * While Tight recommends opting into consuming the new lifecycle webhooks, the existing webhooks remain available so as to not break existing implementation. Their documentation has been moved [here](https://docs.tight.com/docs/legacy-lifecycle-webhooks).

  ### Invoicing

  * **Automatic Reconciliation of Direct Invoice Payments**: Automatic reconciliation of bank deposits against Invoices that accept direct payments.
  * **Finalized Invoices:** Ability to edit both open and closed invoices.
  * **Invoice Refund Tracking Improvements:** Enhancement to account for invoice payment refunds on the Transactions Dashboard.

  ### Accounting

  * **Addition of Beginning Balance Field:** New API-only connection between bank account and its beginning journal entry to view beginningBalanceEntryId to properly track account balances.
  * **Payout Matching Enhancements:** Support for bank transfers as children of payouts.
  * **Reports API**: Ability to perform projections in the P\&L report in API.
  * **Accountant Endpoint**: New endpoint [GET/accountant/userInfo](https://docs.tight.com/reference/getaccountantuserinfo) to retrieve info for an accountant.

  ### Embedded UI

  * **Read-only parameter**: [Embedded UI](https://docs.tight.com/docs/embeddable-ui-getting-started#embedding-specific-components) `renderScreen` function now accepts `readOnly` option to make rendered screens read-only.

  ## Bug Fixes

  ### Invoicing

  * Fix to now properly pull search results for invoice payments on transaction-related dashboards.
  * Corrections to not show split expense parents on the invoice line item expense selection.
  * Fixes to correctly track bank transfers converted to invoice payments as debits into the bank transfer’s bank account.

  ### Embedded UI

  * UI fix to show all content in the onboarding banners on mobile devices.
  * Minor UI fix to the manual journal entry form for long GL account names.

  ### Accounting

  * Enabled the conversion between S Corp and C Corp to other entities without error.
  * Fixes to allow the frontend to convert a payout’s itemized transactions.
  * Fixes to historical payout matching, specifically when the status of itemized transactions are modified.
  * Bench-imported accounts now correctly show with other migrated accounts.

  ### API

  * API validation to prevent the deletion of default client(s).
  * Corrected validations for invalid `clientId` on invoicing APIs.
  * Correctly expose `reviewStatus` for invoice payments on [/getTransactions](/v5.0/api-reference/banks/get-transactions) endpoint.

  ### Integrations

  * Bug fix to sync new accounts from Plaid when they are opened on the connection.
</Update>

<Update label="March 21, 2025">
  Revenue account selection on Invoice line items, Aged Accounts Payable report, and Transaction Rules in the Audit Trail.

  ## New Brand

  Today, my team and I have soft-launched our new brand name, Tight, along with our new website at tight.com and new logo representing the flow and balance of debits and credits, bound together by a tight knot. This name was initially inspired by the saying “keep your books tight,” and also evoked “tight integration,” the essence of embedded accounting. Finally, it evolved into this: “When your customers do their accounting on YOUR platform – that’s Tight.”

  Our new brand is reflective of the tight partnership we have with all of you. Your feedback and collaboration has been instrumental in our growth and product evolution. We’ve been investing heavily in our product and team (50% headcount increase over the past six months) and are continuing to build out new features to meet the needs of your users.

  Otherwise, there is no other change; we are the same company, same team, and same product… we simply have a new brand name. [Hurdlr](https://www.hurdlr.com) remains as a direct-to-SMB mobile and web app for freelancers and small business. [Tight is the embedded accounting product](https://www.tight.com) that you have embedded into your software platforms to serve the small businesses that use your platform.

  Thank you, and let's continue to keep it Tight!

  ## New Features/Enhancements

  ### Invoicing

  * **Stripe Payment Processing:** Reduced Stripe merchant fees by automatically saving client payment methods.
  * **Line Item Revenue Account:** Now allows selection of a revenue account for each invoice line item.
  * **Email Errors API:** Programmatic access to setting email errors on invoices for use in Embedded UI.
  * **Refund API:** A new [endpoint](https://docs.tight.com/reference/postrefundinvoice) has been added for programmatically refunding invoices.
  * **Payment Processing Tutorial:** A new listener in the Embedded UI adds a CTA that allows customer partners to route users to a payment processing tutorial.
  * **Invoice Audit Trail:** Ability to audit changes to invoices, including a history of client interactions. This functionality is currently only accessible from the accountant-facing Embedded UI and via [API](https://docs.tight.com/reference/auditinvoice).
  * **Invoice Payments:** Minor UI update removes the prompt to set up a payment processor for an invoice when payments are already associated with that invoice.

  ### Bank Transactions

  * **Audit Trail:** The Audit Trail now logs the rule used to categorize each transaction.
  * **Rule Matching:** Expense rule matching now defaults to the most recent matching rule when multiple rules apply.

  ### Integrations

  * **Rutter:** Enhanced payout matching for the Rutter integration.
  * **Plaid:** Updated the Plaid integration to utilize the new `persistent_account_id` for better bank account de-duplication.
  * **Integrations API:** Introduced a [DELETE /integration](https://docs.tight.com/reference/deleteintegration) endpoint for disconnecting a user’s integration via the Tight API.
  * **Lifecycle Event:** Added the `INTEGRATION_REPAIRED` event to notify when an integration connection has been repaired.

  ### Reports

  * **Aged Accounts Payable:** New Aged Accounts Payable report supported via both API and UX.
  * **Aged Accounts Receivable:** Enhanced with drill-down functionality.
  * **Trial Balance:** Updated to include custom data support on GL accounts, additionally reflected in the Trial Balance Report.

  ## Bug Fixes

  ### Accounting

  * Fixed issues with deleting and restoring invoice payments.
  * Corrected signage on manual journal entries in bank reconciliations.
  * Added an alert when attempting to cancel an invoice in a closed year.

  ### Invoicing

  * Corrected the display of clients in invoice settings on mobile devices.
  * Fixed UI issues for invoice line items on mobile.
  * Resolved some issues with expanding and reordering invoice line items.
  * Enabled invoiced expenses to be reconciled.
  * Corrected the UI for the source name on direct / cash invoice payments.

  ### Bank Transactions

  * Prevented the matching of expenses to deleted payrolls.
  * Corrected the API to more consistently include default clients on bank transactions when one is not provided.

  ### Client Management

  * Fixed the API for fetching clients using a given businessId.
</Update>

<Update label="February 20, 2025">
  Release of Rutter integration, Manual Journal Entry API idempotency, and other API enhancements.

  ## New Features/Enhancements

  ### Integrations

  * **Rutter Updates:** New integration with Rutter to provide access to [their many commerce integrations](https://docs.rutter.com/support-by-endpoint?activeTab=commerce).

  ### Accounting

  * **Manual Journal Entries Update:** Support for [idempotency](https://en.wikipedia.org/wiki/Idempotence) on Manual Journal Entries API.
  * **Bank Reconciliation:** Bank Reconciliations belonging to merged or otherwise deleted bank accounts will always be accessible in the Reconciliation Dashboard.

  ### Invoicing

  * **External Invoicing Support:** Improved support for programmatically syncing Invoices from non-Hurdlr systems for tighter integrations with customer-partners’ external invoicing implementations.
  * **Invoice Payments API:** Inclusion of `invoiceId` in response for INVOICE\_PAYMENT transactions on  [POST /getTransactions](https://www.hurdlr.com/v5.0/api-reference/banks/get-transactions) endpoint for invoices.

  ### API

  * **Account Creation Errors:** Improvements to account creation error handling providing more programmatic-safe error messages.
  * **Account Restoration Authentication:** Support for Partner-level authentication on [POST/restoreAccount](https://www.hurdlr.com/reference/postpartnerrestoreaccount) endpoint.
  * **Bank Transactions:** Ability to filter by \`reviewStatuses\` on [POST /getTransactions](https://www.hurdlr.com/v5.0/api-reference/banks/get-transactions).

  ### Imports

  * **QBO Modern Report:** Updated instructions for exporting QBO’s “modern” reports when performing a [QBO Migration](https://www.hurdlr.com/docs/quickbooks-online) in the Embedded UI.

  ## Bug Fixes

  ### Accounting

  * Manual Journal Entries are correctly included when pertinent bank accounts are merged.
  * Corrections to ensure that Manual Journal Entries’ amounts display correctly on Bank Reconciliations.
  * Fixes to properly split expenses belonging to [Manually Tracked Accounts](https://www.hurdlr.com/docs/transaction-dashboard-user-guide#manually-tracked-accounts) even after being merged into a Plaid-linked bank account.

  ### Bank Transactions

  * Fixes to payout matching for advanced transaction types and negative payouts.
  * Better handling of matching Bank Transfers when deleting or updating matches.
  * Fixes to [POST/getTransactions](https://www.hurdlr.com/v5.0/api-reference/banks/get-transactions) when filtering on a specific Revenue \`id\`.
  * Pagination bug fix on [GET /expenses](https://www.hurdlr.com/reference/getinterviewexpenses).

  ### Reports

  * Fix to Financial Report drilldowns bug when multiple General Ledger accounts share the same account number.

  ### Imports

  * Bug fix to correctly handle Revenue refunds in Bench import.

  ### Invoicing

  * Correction to stop sending reminders on Invoices with a pending Invoice Payment.
  * Fix to allow opening of attachments on Invoices.
  * Ability to generate PDFs for Invoices migrated from legacy accounting platforms.
  * Fixes to include CC and BCC emails when duplicating an Invoice.

  ### Tax

  * Fixed bug causing crashes on the Tax Dashboard when rendering Embedded Experience in Spanish.
  * Correction to the constant used on line 21 of the Schedule D (Form 1040).

  ### Embedded UI

  * Bug fixes to Business Intelligence Tiles’ callback events to match their UI more accurately.

  ### API

  * Fix to allow the account creation for bizNames that are shorter than 3 characters after the removal of whitespace.
</Update>

<Update label="January 30, 2025">
  Enhancements to the Invoicing user experience, Bank Transaction functionality, and availability of 2025 Tax Filing and Estimates.

  ## New Features/Enhancements

  ### Invoicing

  * **Ability to edit finalized Invoices:** Ability for users to make edits to Invoices that have already been finalized and/or sent to their clients.
  * **API Update:** Ability to include relevant Invoice Payment data on [GET /invoices](https://www.hurdlr.com/reference/getinvoices) via new API parameter, `includePayments`.
  * **Invoice Message**: The Invoice message now allows emojis and other unicode characters.
  * **Payment Processing Options:** Ability to specify what [Payment Processing options](https://www.hurdlr.com/docs/embeddable-user-interface-invoice-dashboard#3-modifying-the-payment-processing-options) users can accept on their Invoices in the Invoice Dashboard.
  * **Recurring Invoices:** Improved UI to distinguish recurring Invoices in the Invoicing Dashboard.

  ### Bank Transactions

  * **Expense Rules:** Ability to create Expense Rules without a Vendor; transactions matching such rules will use the Vendor already associated with the given transaction.
  * **Plaid Historical Pull Improvements:** More robust validations in place during historical transaction pulls to avoid transaction duplicates for banking institutions that have been unlinked and relinked with Plaid.
  * **Import CSV:** Update to display a transaction’s description as its Vendor when a Vendor is not provided during the review flow.

  ### Tax

  * **2024 US Tax Forms**: Updated Form 1120-S and Form 1120 population for 2024 (commonly filed between April and October 2025), accessible through the Taxes Dashboard and via [API](https://www.hurdlr.com/reference/postreport).
  * **2025 Canada Tax Estimates**: Review of all 2025 Canadian tax forms and subsequent updates to Hurdlr's tax engine for precise [Tax Estimates](https://www.hurdlr.com/docs/tax-calculations) on 2025 data with full Canadian support (federal and all 10 provinces).

  ### Integrations

  * **Bank Account Refresh:** Updates to the Plaid integration  to perform additional updates on Bank Account metadata if Plaid modifies this information.
  * **Stripe Updates:** Inclusion of Stripe’s account identifier on [GET /integrations](https://www.hurdlr.com/reference/getintegrations).

  ### Imports

  * **QBO Modern Report Support**: Support for QBO’s new “Modern” reports in the [QBO Import](https://www.hurdlr.com/reference/importqbo).
  * **Import Validations**: Improved validations to the provided reports for easier self-service when performing Accounting Imports.

  ## Bug Fixes

  ### Accounting

  * Fixed bug preventing the bulk tagging of Tax Payments.
  * Fixes to GL Entry creation for matching Bank Transfers.
  * Corrections to GL account names for Plaid-linked Bank Accounts to safely include the name of the corresponding banking institution.

  ### Bank Transactions

  * Fixes to correctly update and/or unmatch a Bank Transfers matching Bank Transfer when relevant modifications are made to the match.
  * Corrected the Audit Trail to now reflect "\<Customer Partner Name> System" for all entries that are system generated.
  * UI bug fixes to now correctly show the ‘Continue’ button when merging long lists of vendors.

  ### Reports

  * Fix for directly embedding the Expenses by Category report.
</Update>

<Update label="January 10, 2025">
  New Invoicing Features: customizable business information and custom invoice numbers & formats.

  ## New Features/Enhancements

  ### Invoicing

  * **Customizable Business Information:** Users can now control exactly what appears on their invoices by customizing business details.
  * **Custom Invoice Numbers & Formats:** Ability to customize invoice numbers and formats at the Client and/or Invoice level.
  * **QBO Import Updates:** The [QBO Import](/docs/qbo-import-user-guide#uploading-reports) now accepts the "Invoices and Received Payments" report for better Invoice and Payment matching.
  * **Email Field Defaults:** Improved defaults for email-related fields in Invoicing APIs.

  ### Accounting

  * **General Ledger Report API Enhancement:** The [API](/reference/postgeneralledger) now accepts `accountNo` for a simplified method to fetch General Ledger entries for specific GL accounts across multiple user accounts.
  * **Bank Account Merging:** Deleted bank accounts with active monthly Closings will now always be included as potential duplicates.

  ### Taxes

  * **2024 Tax Forms:** Updated Form 1040 Schedule C and Form 1065 population for 2024 (commonly filed between April and October 2025), accessible through the Taxes Dashboard and via [API](https://www.hurdlr.com/reference/postreport).

  ## Bug Fixes

  ### Accounting

  * Fixed issues with drilling down into "Capital Stock," "Owner's Draw," and other related Equity accounts from the Balance Sheet.
  * Corrected the duplication of General Ledger entries for archived and converted Bank Transactions.
  * Fixed Journal Entries for Tax Payments, ensuring they update correctly when the linked bank account is changed.
  * Addressed issues with saving Bank Reconciliations when matching Bank Transfers.

  ### Bank Transactions

  * Resolved bug causing duplicate Plaid Bank Transactions.
  * Fixed display issues for manually entered transactions merged into Plaid bank accounts.

  ### Imports

  * Fixed issues with parsing Excel files during Xero Imports.
  * Updated Bench import to support their latest offboarding package.

  ### Invoicing

  * Fixed issue with archiving Invoice Payments attached to archived invoices.
  * Removed the 'Create Link' option from scheduled invoices.

  ### Payroll

  * Fixed the ability to attach Expense refunds to Payroll entries for better support of Payroll reversals.
</Update>

<Update label="December 16, 2024">
  Enhancements to user onboarding in the Embedded UI, Invoicing, and Bank Transaction classification.

  ## New Features/Enhancements

  ### Embedded UI

  * More informative CTAs on zero states for the Expense, Revenue, Invoicing, and Time & Tasks Dashboards to help drive activation.
  * Addition of [optional tooltips on each of the Business Intelligence tiles](https://www.hurdlr.com/docs/business-intelligence-tile-components#8-displaying-tile-tooltips) for better user education.
  * New copy on the rule form to provide explanations for using rules.
  * Inclusion of character counters on all text-area fields.
  * Updates to prevent accountants from editing user-level information, e.g. email.

  ### Invoicing

  * The Invoice message field now respects line breaks.
  * Ability to edit Invoice settings inline in the Embedded UI.
  * Addition of `status` filtering on [GET /invoices](https://www.hurdlr.com/reference/getinvoices)[.](https://www.hurdlr.com/docs/invoicing-api)

  ### Integrations

  * API and UX handling of [new Plaid webhooks for pending disconnects](https://plaid.com/docs/api/items/#pending_disconnect).
  * Enhancement to allow unlinked bank accounts to be merged into linked bank accounts.

  ### Transactions

  * Improvements to vendor identification and matching on CSV and Accounting imports.
  * UI and UX enhancements to the CSV Import in the Embedded UI.
  * Improved transaction details in Income reports for Invoice Payments.

  ### Accounting

  * More robust validations for General Ledger account numbers.
  * Improved automated reconciliation of withdrawals against their corresponding payrolls.
  * Accounting imports can be run on users that have already used Invoicing.

  ### Taxes

  * Tax Estimates now use the last twelve months of user data when calculating projected estimates.

  ### API

  * `userId` is now editable on [POST /userInfo](https://www.hurdlr.com/reference/postuserinfo).
  * Partners can opt-in to release the `email` uniqueness constraint on Hurdlr accounts, useful for multi-company setups. Please reach out if you would like to opt in.

  ## Bug Fixes

  ### Accounting

  * Fixes to timezone-related issues on Bank Reconciliation.
  * Fix to the creation of bi-weekly Manual Journal Entries.
  * Fix when updating a bank account’s GL account to ensure the update only impacts that bank’s transactions.

  ### Integrations

  * Correctly hide deleted imported bank accounts.
  * Fix to correctly display the bank account on manually imported transactions after being merged into a linked bank account.

  ### Invoicing

  * Fix to allow for the reordering of invoice line items.

  ### Transactions

  * Fixes to the attachment of receipts for an existing/tagged transaction.

  ### Payroll

  * Fix to improve the matching of GL account categories for payroll.
  * Bug fixes for processing and display of split Payroll expenses.

  ### Reports

  * Fix to allow emailing of all downloadable reports.
</Update>

<Update label="November 26, 2024">
  Enhancements to Invoicing and Payroll and Bank Transaction matching algorithms.

  ## New Features/Enhancements

  ### Invoicing

  * Addition of the Aged Accounts Receivable Report preview on the Invoicing Dashboard.
  * Removal of limit to number of line items on invoice form.
  * UI Improvements to visually disable ACH/CC payment options on invoices if Stripe is not linked.

  ### Integrations

  * Addition of a [new endpoint](/reference/postintegration) which allows programmatic creation of OAuth linkages in the Hurdlr API for some of our native integrations, e.g. [Stripe](/integrations/payment-processing/stripe#connect-your-user’s-stripe-accounts).
  * Inclusion of tax filing related [events for the Mixpanel integration](/docs/mixpanel-events).

  ### Accounting

  * Improvements to Payroll and Bank Transaction matching algorithms.
  * Update to completely hide duplicate bank accounts once merged.

  ### Embedded UI

  * Minor enhancement to all dashboards to only allow one field dropdown to be open at a time.

  ## Bug Fixes

  ### Invoicing

  * Fix to allow duplicating archived invoices.
  * Fixes to allow deletion of QBO/Xero imported Invoice Payments.

  ### Accounting

  * Fixes to conversions and matching of Bank Transfers during Bank Reconciliations.
  * Fixes to split expense handling in Bank Reconciliations.
  * Fixes to ensure pertinent Invoice Payments show on corresponding Bank Reconciliations.
  * Time zone fixes to correctly reflect the correct date on manual Journal Entries.
  * Fixes to tax treatment of “Dues and Subscription” expenses on the Form 1065 and tax reports.

  ### Patches

  #### 41.8.1

  * Time zone fixes for accurate transaction display on Bank Reconciliations.
</Update>

<Update label="October 31, 2024">
  Enhancements to Embedded UI versioning, Accounting Migrations, Invoicing, and Financial Reports.

  ## New Features/Enhancements

  ### Embedded UI

  * Ability to delay opting into the latest releases of the [Embedded UI](/docs/embeddable-white-labeled-experience)
    * Requires a [slight change](/docs/embeddable-ui-getting-started)  in the way the Embedded UI is added to an your application. Existing implementations are safe.

  ### Imports

  * Update to [QBO Import](/docs/quickbooks-online) to consume QBO’s "Invoices and Received Payments" report for improved invoice to payment matching.

  ### Invoicing

  * Ability to filter to scheduled invoices from the [Invoice Dashboard](/docs/embeddable-user-interface-invoice-dashboard).
  * Increased character limit of 800 for “Message” field on invoices.
  * Updates to formatting of invoice lines items on the invoice form to be clearer and more consistent with the invoice PDF.
  * Addition of dismissible Stripe Payment Processing setup CTAs.

  ### Reports

  * Improved default ordering of reports on the [Report Dashboard](/docs/report-dashboard) to be more accounting focused.

  ### Accounting

  * Addition of warning when merging bank accounts or vendors to indicate that the action cannot be undone.

  ### Transactions

  * API addition of `reviewStatus` to transaction-related APIs, e.g. [POST /getTransactions](/v5.0/api-reference/banks/get-transactions).
  * Minor language updates to conversion UI on [transaction forms](/docs/transaction-form).

  ## Bug Fixes

  ### Invoicing

  * Fixes to `customData` on [GET invoices](/reference/getinvoices).
  * Better error handling on [client invoice payment screen](/docs/embeddable-user-interface-client-invoice).

  ### Accounting

  * Fixes to respect a user’s `availableFeatures.bookkeeping` when granting and revoking access to accountants in the Hurdlr API.
  * Fix to prevent virtual bank accounts from using the same GL account.

  ### Transactions

  * Fixes to [/getTransactions endpoint](/v5.0/api-reference/banks/get-transactions) to now include active TaxPayments.
  * Fixes to bulk categorization from the [Transactions Dashboard](/docs/transactions-dashboard).
  * Fixes to correctly expand the Bank Transfer form when editing withdrawal [payouts](/docs/payout-user-guide).
  * Updates to Audit Trail to show the correct editor on the initial entry for all transactions.

  ### Patches

  #### 41.7.1 through 41.7.2

  Bug fixes and minor improvements.
</Update>

<Update label="October 17, 2024">
  Enhancements to Invoicing, Accounting, Bank Transactions, and API Authorization.

  ## New Features/Enhancements

  ### Invoicing

  * Improvements to [Stripe Integration](/docs/stripe) for increased accuracy of matching Stripe [Payouts](/docs/payout-user-guide) to their itemized transactions, including Stripe Climate Contributions and other obscure items.
  * Addition of “All” option to [Invoice Dashboard](/docs/embeddable-user-interface-invoice-dashboard) filters.

  ### Accounting

  * Ability to specify both the cash and accrual transactions on a [Manual Journal Entry](/docs/general-ledger-component) via [API](/reference/postmanualjournalentry).
  * Addition of the manualJournalEntry entity to our [Entity Update Webhooks](/docs/webhooks).

  ### Bank Transactions

  * Improvement of the display of split expenses on all transaction-related dashboards.
  * Ability to define the user-level and accountant-level access of individual transactions, via new userAccess and accountantAccess fields ([Revenue](/reference/postrevenue) for reference).
  * Ability to merge bank accounts in the Embedded UI and API.
  * Ability to merge vendors via UX and API.

  ### API

  * Introduction of Partner-level authorization

  ## Bug Fixes

  ### Transactions

  * Fixes to ingestion of [Stripe](/docs/stripe) payment data.
  * Fixes to advanced filtering and searching on [transaction tables](/guides/business-owners/bank-transactions).
  * Updates to the display of payment source information for better Invoice Payments UI.
  * Fixes to customData on [Bank Transfer](/reference/postbanktransfer) entities.

  ### Reports

  * Fixes to totals on the Aged Accounts Receivable Report.
  * Fixes to drill down on the total column on the [Profit & Loss Report](/embeddable-ui/react/financial-statements/profit-loss-report).

  ### Bank Reconciliation

  * Fix to the display of beginning balances when viewing completed Bank Reconciliations.
  * Fixes to the bank institution logos displayed on the Reconciliation Dashboard.

  ### Patches

  #### 41.6.1 through 41.6.5

  Bugfixes and minor improvements.

  #### 41.6.6

  Modifications to support SDK versioning released in 41.7
</Update>

<Update label="September 12, 2024">
  Enhancements to Bank Transactions, Invoicing, Business Intelligence Tiles, and Bills

  ## New Features/Enhancements

  ### Bank Transactions

  * All possible transaction conversions are now available via API.
  * Ability to hide the overview graphs at the top of the [Expense](/docs/expense-dashboard) and [Income](/docs/income-dashboard) Dashboards in the Embedded UI. This can be accomplished by passing an additional parameter to the Embedded UI’s render options, `showDashboardOverview: false`
  * Ability to [merge vendors via API](/reference/postvendor).
  * Addition of `apiName` field via [POST /getTransactions API](/v5.0/api-reference/banks/get-transactions).
  * Addition of a new [lifecycle event webhook](/docs/webhooks#4-lifecycle_event) for newly ingested uncategorized expenses, `EXPENSE_REVIEW_NEEDED`.

  ### Invoicing

  * Income reports updated to include invoice payments for improved consistency between these reports and their respective Embedded dashboards.
  * Improvement to bank transactions search on the invoice form.

  ### Business Intelligence Tiles

  * Ability to hide the taxes line item on [Profit & Loss Tile](/docs/business-intelligence#3-profit--loss-tile) for a more accounting-centric view. This line item will be hidden automatically for Partners who are not using the Tax Tile.

  ### Bills

  * Improvements to Bills in the Embedded UI to display the pertinent category on the bill row.

  ## Bug Fixes

  ### Accounting

  * Fixes to correctly display Manual Journal Entry dates on Journal/[General Ledger](/docs/general-ledger-component) and to ensure the ability to delete Manual Journal Entries is accessible on all entries.
  * Fixes to maintain “None” grouping filter when navigating to and from reports, e.g. for General Ledger drill downs.

  ### Invoicing

  * Invoices will be marked as refunded when all of their payments are manually refunded via API.
  * UI fixes to expanded display of Payouts on the [General Ledger Dashboard](/docs/general-ledger-component).
  * Fixes to display of merchant fees on older Payouts in the [Transaction](/docs/transactions-dashboard)/[Income](/docs/income-dashboard) Dashboards.
  * Fixes to ensure all canceled invoice payments are correctly hidden on active transaction views.
  * Fixes to some total amount validation issues when matching multiple invoices to a single deposit.
  * Ability to add [attachments without captions to invoices via API](/reference/uploadattachment).
  * Fixes to display issues for older cash payments that lacked descriptions.

  ### Transactions

  * More robust access to the Audit Trail for all transactions.
  * Updates to the Advanced Search filters to allow bank accounts without an account mask to be selected.
  * Fixes to transactions API to enable the creation of transactions without the specified client getting overwritten.

  ### Miscellaneous

  * Improvement of idempotence on transaction `DELETE` endpoints so an error is no longer returned on already deleted entities.
  * Updates to read-only users to correctly block editing of transactions in the [General Ledger](/docs/general-ledger-component).

  ### Patches

  #### 41.5.1 through 41.5.3

  Bugfixes and minor improvements.

  #### 41.5.4

  Modifications to support SDK versioning released in 41.7
</Update>

<Update label="August 23, 2024">
  New General Ledger API and improved display of the connection between the payout and its itemized transactions.

  ## New Features/Enhancements

  ### General Ledger

  * The General Ledger can be exported as a CSV directly from the [General Ledger dashboard](/docs/general-ledger-component). The new report is also available via [API](/reference/postgeneralledger).

  ### Invoicing / Payouts

  * Better display of the connection between the payout and its itemized transactions.
  * Ability to match bank transactions directly from the Invoice form.
  * Updates to cash/check payment language to reference “direct payments.”
  * Invoice payments can be deleted via [DELETE /payment](/reference/deletepayment) endpoint.
  * Improved title on the Invoice form to more accurately reflect the invoice’s status.

  ### Reports

  * Support for multi-period [Cash Flow Statement](/docs/cash-flow-statement) in the Embedded UI.
  * Performance improvements to [Cash Flow Statement](/v5.0/api-reference/reports/cash-flow-statement-direct) generation.

  ### UX Enhancements

  * Updates to block Embedded UI screens based on users’ [available features](/docs/creating-a-user).

  ### Unit Integration

  * Improvements to [Unit](/docs/unit-integration) transaction parsing for more detailed descriptions on transactions.

  ### BI Tiles

  * Enhancements to the [Cash Flow tile](/docs/business-intelligence#4-cash-flow-tile) to more accurately depict users’ business cash flow and match the Cash Flow Statement.
  * Enhancements to the [Income tile](/docs/business-intelligence#7-income-tile) and [Expense tile](/docs/business-intelligence#6-expense-tile) to include manual journal entries in totals.

  ## Bug Fixes

  * Fixes to the 3-dot pagination loader at the bottom of all transaction-related dashboards.
  * Fixes to loader in the zero state on the [General Ledger dashboard](/docs/general-ledger-component).
  * Updates to the [Expense BI tile](/docs/business-intelligence#6-expense-tile) to only include business expenses.
  * Correction to [Cash Flow Statements](/docs/cash-flow-statement) to correctly include security deposit expenses.
  * Improvement to Attachments API to maintain a single invoice logo per business.
  * Data fix to remove duplicate invoice payments for users that hit a rare duplicate payment bug.
  * Fixes to correctly invoke invoicing payment processor listeners when setting up payment processing directly from the Invoice form.
</Update>

<Update label="July 30, 2024">
  Enhancements to Stripe Integration for improved connection to Hurdlr Invoicing.

  ## New Features/Enhancements

  ### Invoicing

  * Stripe account data can be ingested via [POST /stripeAccountId endpoint](/v5.0/api-reference/invoicing/save-a-stripe-account).
  * More detailed invoice payment data available via [API](/reference/getpayments).
  * Invoices can be sent from the user’s business name instead of their email address.

  ### Accounting

  * Support for recurring journal entries in the Embedded UI and [API](/reference/postmanualjournalentry).

  ### Transactions

  * Ability to split expenses for business-only accounts into business and personal expenses.
  * Update Bank Transfers to include additional metadata in [API](/reference/getbanktransfers).

  ### Embedded UI

  * The ability to [hide animations in the Embedded UI](/docs/next-steps-user-interface#2-customizing-the-embedded-ui-to-match-your-branding).

  ## Bug Fixes

  * Fix to JSON API response format for [Profit & Loss JSON report](/api-reference/reports/profit-and-loss).
  * Fix to Balance Sheet for better handling of suspense accounts.
  * Fixes to Cash Flow Statement to be consistent with other reports.
  * Fixes to bank reconciliations on deleted bank accounts.
  * Fixes to Chart of Accounts aggregate figures.
  * UI fixes on invoice form.
  * Minor display fixes for dates on the General Ledger.
  * Fixes to transaction conversions.
</Update>

<Update label="July 12, 2024">
  Read-only scope for restricted access in the API and Embedded UI along with other enhancements to Invoicing and Bank Transactions

  ## New Features/Enhancements

  ### UX Enhancements

  * User’s role can be set to `READ_ONLY` [via API](/reference/postuserinfo) to restrict the Embedded UI to a read-only view.

  ### Audit Trail

  * Transactions can be audited in the Embedded UI and [via API](https://www.hurdlr.com/reference/auditexpense) to view a revision history for that transaction.

  ### Invoicing

  * Inclusion of invoice payments in the [Transaction](/docs/transactions-dashboard) and [Income](/docs/income-dashboard) Dashboards.
  * Update to invoice picker on the [Transaction](/docs/transactions-dashboard) and [Income](/docs/income-dashboard) Dashboards to include the invoice date.
  * Stripe customer and payment data can be ingested via [POST /payments endpoint](/v5.0/api-reference/invoicing/process-payment).

  ### Transactions

  * [The ability to render a single transaction form overlayed in the partner’s app](/docs/transaction-form).
  * Enhanced matching and categorization of expense refunds.

  ### Reports

  * UI support for pulling partial month Balance Sheets.
  * Ability to generate comparative Trial Balance reports.
  * Performance improvements for the Trial Balance report.

  ### Accounting Migrations

  * Enhanced detection of revenue refunds in accounting imports.
  * Enhancements to [QBO Import](/reference/importqbo) to handle reimbursed expenses.

  ### Bank Reconciliation

  * Bank reconciliations automatically merged when corresponding bank accounts are merged.

  ### Analytics

  * Enhancements to the [Mixpanel](/docs/mixpanel-integration) and [Intercom](/docs/intercom) integrations to accept expanded configurations.

  ## Bug Fixes

  * Fixes to date handling on bank reconciliations.
  * Fixes to drill-down reports.
  * Fixes to Chart of Accounts to ensure correct balances are displayed.
  * Fixes for timezone issues when pulling reports.
  * Minor fixes to Bank Transfer conversions and matching.
  * Update to [Stripe integration](/docs/stripe)  so transactions always have distinct API ids.
</Update>

<Update label="June 14, 2024">
  Enhancements to Tax Estimates, Accounting Migrations, and API performance

  ## New Features/Enhancements

  ### Taxes

  * Prior quarterly tax obligations always roll into the current quarter.
  * Tax estimates displayed even with no business income tracked.

  ### Accounting Migrations

  * Hurdlr [API](/v5.0/api-reference/imports/import-bench) and Embedded UI support for importing users’ data from Bench.
  * Improved ingestion of invoices and invoice payments.

  ### Embedded UI Updates

  * [Routing from the Business Intelligence Tiles](/docs/business-intelligence-tile-components#7-routing-the-tiles) can be defined on a specific set of tiles, allowing partners to still take advantage of Hurdlr’s expandable [Profit and Loss tile](/docs/business-intelligence#3-profit--loss-tile).
  * `options.showAnimations` can be set to `false` to disable animations in the Embedded UI.

  ### API Improvement

  * Addition of `deletedIds` to attachments API.

  ### Performance Enhancements

  * Faster rendering of the Trial Balance report.
  * Performance improvements for loading of the Journal and General Ledger.

  ## Bug Fixes

  * Fixes for rendering the correct balances when flipping between the Profit & Loss and Balance Sheet.
  * Fixes to the General Ledger rendering to ensure all entries are displayed.
  * Fixes so scheduled invoices send on their scheduled date.
  * UX fix for the Plaid [NO\_ACCOUNTS](https://plaid.com/docs/errors/item/#no_accounts) error, so the financial institution can be unlinked in the Embedded UI.
</Update>

<Update label="June 3, 2024">
  Enhancements to Bank Transaction automatic reconciliation and performance on the core Financial Reports.

  ## New Features/Enhancements

  ### Performance Enhancements

  * Balance Sheet and Profit & Loss render 80% quicker (80% less latency).
  * [General Ledger endpoint](/reference/getgeneralledgerentries) responds 15% quicker (15% less latency).

  ### Bank Transfer Matching

  * Bank Transfers can be matched with any transaction of the same amount, which automatically converts to a Bank Transfer.

  ### Accounting Migrations

  * [Xero](/reference/importxero) and [QBO](/reference/importqbo) migrations support importing XLS/XLSX files in addition to prior CSV support.

  ### Accountant Dashboard

  * Accountants can [automatically get access to all users](/v5.0/api-reference/accountant/create-an-accountant) by setting `canAccessAllUsers` to `true`.

  ### Plaid

  * New function added to render [Plaid Link directly over your existing onboarding UI](/docs/plaid-integration#4-plaid-link-new-implementation), removing the need to manually pass Plaid `access_tokens` to the Hurdlr API

  ### Transactions UI

  * The `bankDescription` field will now be displayed when hovering over transaction rows on the transactions and reconciliation dashboards.

  ### Bug Fixes

  * Fixes to `deletedIds` on [GET /generalLedgerEntries](/reference/getgeneralledgerentries).
  * Fixes to CSV Import Completed alert to include counts for bank transfers and tax payments.
  * Fixes to date filtering when drilling down into “Current Income” from Balance Sheet.
  * Removal of Equity/Liabilities income from business income reports.
  * Improved consistency of date-pickers throughout the Embedded UI.
</Update>

<Update label="H1 2024">
  Infrastructure improvements to general ledger, consuming APIs, and monitoring resulting in increased performance (financial reports spanning multiple years generated in milliseconds), robustness (stronger SLAs), and a SOC 2 Type 2 audit completed with zero exceptions. Public exposure of the Audit Trail.
</Update>

<Update label="2023">
  Launch, including iterations with thousands of businesses, of multi-year imports from [QuickBooks Online](/docs/quickbooks-online) and [Xero](/docs/xero)
</Update>

<Update label="2022">
  Launch of dedicated [Accountant Dashboard](/docs/bookkeeper-dashboard), to streamline operations for large Virtual Bookkeeping firms, while keeping the business owner-operator experience simple.
</Update>

<Update label="2021">
  Launch of many [native integrations](/integrations/native-integrations) per customer-partner requests.
</Update>

<Update label="2020">
  First public release of the Embedded UI, for new customer-partners desiring Hurdlr’s proven user experience.
</Update>

<Update label="2019">
  First public release of the Hurdlr API, for the launch of Hurdlr’s first API customer-partner. This release made the Hurdlr API, privately consumed by hundreds of thousands of SMBs by way of the Hurdlr app (lanched in 2015), public for the first time.
</Update>

<Update label="2012-2018">
  Founded in 2012, API development started with the double-entry general ledger with full Audit Trail and then expanded into invoicing, income/expense tracking, financial statements, and income taxes. Learning the “Embedded” space did not yet exist, the Hurdlr app was built and ultimately released in 2015 to showcase the API’s features. The Hurdlr app ultimately grew to hundreds of thousands of small business owners, allowing the API to reach product maturity and cover the many edge cases faced by real users in production. In 2019, Hurdlr received its first organic API lead, realizing its initial API-first product vision.
</Update>