---
title: "Cashbook"
description: "The CashBook is a dictionary where the keys are currency tickers and the values are Cash objects. The Cash objects track the portfolio currencies."
canonical: https://www.quantconnect.com/docs/v2/writing-algorithms/portfolio/cashbook
markdown: https://www.quantconnect.com/docs/v2/writing-algorithms/portfolio/cashbook.md
language: python
source: https://github.com/QuantConnect/Documentation/tree/master/03%20Writing%20Algorithms/08%20Portfolio/04%20Cashbook
modified: 2026-10-29
index: https://www.quantconnect.com/llms.txt
---

# Cashbook

[Documentation](https://www.quantconnect.com/docs/v2.md) > [Writing Algorithms](https://www.quantconnect.com/docs/v2/writing-algorithms.md) > Portfolio > Cashbook

> Code examples are shown in Python. Append `?lang=csharp` to this URL for the C# version of this page.

## Introduction

The `CashBook` is a dictionary where the keys are currency tickers and the values are `Cash` objects. The `Cash` objects track the amount of each currency in the portfolio. As you buy and sell securities, LEAN credits and debits the `Cash` objects to reflect your cash holdings.

## Account Currency

The default account currency is USD, but you can change it. All of the [properties of the Portfolio object](https://www.quantconnect.com/docs/v2/writing-algorithms/portfolio/key-concepts.md#98-Properties) that return a currency value denominate the currency value in your account currency. Depending on your account currency and security subscriptions, LEAN may add internal security subscriptions to calculate the `value_in_account_currency`. For example, if you only add BTCETH to your algorithm and set the account currency to USDT, LEAN adds BTCUSDT and ETHUSDT as internal feeds.

To get your account currency, use the `account_currency` property.

```python
account_currency = self.account_currency
```

To set your account currency, in the `initialize` method, call the `set_account_currency` method. You can only set the account currency once. LEAN ignores each additional call to `set_account_currency`.

```python
self.set_account_currency("EUR")
```

## Settled vs Unsettled Cash

The `portfolio` has two independent cashbooks. The `cash_book` tracks settled cash and the `unsettled_cash_book` tracks unsettled cash, which you can't spend. If you trade with a margin account, trades settle immediately so LEAN credits and debits the `cash_book` at the time of the trade. In some cases, transactions can take time to settle. For example, Equity and Option trades in a cash account settle in T+1. Therefore, if you sell shares of stock on Monday, the transaction settles on Tuesday.

```python
settled_cash_book = self.portfolio.cash_book
unsettled_cash_book = self.portfolio.unsettled_cash_book
```

## Track Cash Balances

To get the balance of a currency in the cash book, use the `amount` property.

```python
# Return the cash book balance in US Dollar amount.
usd = self.portfolio.cash_book["USD"].amount
# Return the cash book balance in Bitcoin amount.
btc = self.portfolio.cash_book["BTC"].amount
```

To get the value of a currency in the cash book, denominated in your account currency, use the `value_in_account_currency` property.

```python
# Return the cash book value of Ethereum in account currency (US Dollar, Euro, etc.) amount.
eth_value = self.portfolio.cash_book["ETH"].value_in_account_currency
```

## Deposits and Withdrawals

In backtests, you can add and remove cash from the cash book. To add or remove cash, call the `add_amount` method.

```python
# Adjust the backtesting cashbook balances to add 100 USD and subtract 1.5 BTC.
new_usd_balance = self.portfolio.cash_book["USD"].add_amount(100)
new_btc_balance = self.portfolio.cash_book["BTC"].add_amount(-1.5)
```

In live trading, add and withdraw cash through your brokerage account. If you adjust the cash balances in your algorithm with the `add_amount` method, the cash balance in your algorithm will be out of sync with the cash balance in your brokerage account.

## Currency Symbols

A currency symbol is a graphic that represents the currency name. For example, $ is for dollars, € for euros, and ฿ for Bitcoin. To get the symbol of a currency in the cash book, use `currency_symbol` property.

```python
usd_symbol = self.portfolio.cash_book["USD"].currency_symbol
```

## Conversion Rates

To get the conversion rate for a currency in the cashbook to your account currency, use the `conversion_rate` property.

```python
eur_conversion_rate = self.portfolio.cash_book["EUR"].conversion_rate
```

## Examples

The following examples demonstrate common practices for controlling the portfolio cashbook.

### Example 1: Dollar Cost Averaging

The following algorithm deposits USD 1000 on every month's start and buys SPY with the deposited cash. It results in a dollar cost averaging investment strategy on the overall market.

```python
class PortfolioCashbookAlgorithm(QCAlgorithm):
    deposit = 1000

    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.set_cash(1000)

        # Request SPY data to trade the overall market representative.
        self.spy = self.add_equity("SPY").symbol

        # Deposit each month start and invest in SPY by dollar cost averaging.
        self.schedule.on(
            self.date_rules.month_start(self.spy),
            self.time_rules.after_market_open(self.spy, 0),
            self.deposit_and_rebalance
        )

        # To warm up the price data of SPY to calculate the quantity to be brought.
        self.set_warm_up(1)

    def deposit_and_rebalance(self) -> None:
        # Deposit the account currency's preset level ($1000) at the month's start.
        # Simulate the monthly salary deposit for dollar cost-averaging investment in the market.
        self.portfolio.cash_book[self.account_currency].add_amount(self.deposit)

        # Calculate the number of shares that can be invested using the deposited amount.
        quantity = self.deposit // self.securities[self.spy].price
        self.market_order(self.spy, quantity)
```

### Example 2: Crypto Cashbook

This example trades an EMA cross strategy on the ETH-BTC crypto pair in a cash account. To obtain the maximum tradable order size, we need to use the cash book and check the amount of BTC in long ETHBTC trades and in short ETHBTC trades to avoid insufficient initial margin.

```python
class PortfolioCashbookAlgorithm(QCAlgorithm):

    buffer = 0.01

    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        # Set the account currency as USDT and set the starting cash in a cash account.
        self.set_brokerage_model(BrokerageName.COINBASE, AccountType.CASH)
        self.set_account_currency("USDT", 100)
        self.set_cash("BTC", 100)
        self.set_cash("ETH", 2000)

        # We would like to trade the EMA cross between 2 popular cryptos BTC & ETH,
        # so we are requesting ETHBTC data to find trading opportunities.
        self.ethbtc = self.add_crypto("ETHBTC", Resolution.MINUTE, Market.COINBASE).symbol

        # Add automatic-updating EMA indicator for trend trade signal emission.
        self._ema = self.ema(self.ethbtc, 50, Resolution.DAILY)
        # Warm up the indicator for its readiness usage immediately.
        self.warm_up_indicator(self.ethbtc, self._ema, Resolution.DAILY)

    def on_data(self, slice: Slice) -> None:
        bar = slice.bars.get(self.ethbtc)
        if not (bar and self._ema.is_ready):
            return
        ema = self._ema.current.value
        # ETHBTC's current price is higher than EMA, suggesting an uptrend.
        if bar.close > ema and not self.portfolio[self.ethbtc].is_long:
            # Convert to the corresponding quantity of the quote currency.
            quantity = self.portfolio.cash_book["BTC"].amount * (1 - self.buffer) / bar.close
        # ETHBTC's current price is below the EMA, suggesting a downtrend.
        elif bar.close < ema and not self.portfolio[self.ethbtc].is_short:
            quantity = -self.portfolio.cash_book["ETH"].amount
        else:
            return
        # Round down to observe the lot size.
        lot_size = self.securities[self.ethbtc].symbol_properties.lot_size
        quantity = int(quantity / lot_size) * lot_size
        if quantity:
            self.market_order(self.ethbtc, quantity)
```