# List investments

URL: https://docs.hanzo.ai/docs/openapi/captable/get-captable-investments

> Returns the caller org's investments, newest first.

`GET /v1/captable/investments`

> [Captable →](https://docs.hanzo.ai/docs/openapi/captable) · [All API references →](https://docs.hanzo.ai/docs/openapi) · [Get started →](https://docs.hanzo.ai/docs/guides)

|               |                                                |
| ------------- | ---------------------------------------------- |
| **Address**   | `https://api.hanzo.ai/v1/captable/investments` |
| **Method**    | `GET`                                          |
| **Operation** | `get_captable_investments`                     |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY`         |

Returns the caller org's investments, newest first. It spans
every round, so it is the flat ledger of cheques written into the company,
each naming its investor and the round it went into.

## Request

`GET /v1/captable/investments` takes no parameters and no body — the credential is the whole request.

## Response

| Status    | Body                         | Meaning |
| --------- | ---------------------------- | ------- |
| `200`     | captable.captableInvestments | ok      |
| `default` | problem-details              | refused |

`200` body — 9 fields.

| Field                    | In   | Type                           | Always | Description                                                                                                   |
| ------------------------ | ---- | ------------------------------ | ------ | ------------------------------------------------------------------------------------------------------------- |
| `data`                   | body | captable.captableInvestment\[] | —      | Data is every investment across every round, newest first.                                                    |
| `data[].amount`          | body | number (double)                | —      | Amount is the cash invested.                                                                                  |
| `data[].date`            | body | string                         | —      | Date is the ISO date of the investment.                                                                       |
| `data[].id`              | body | string                         | —      | ID is the investment id.                                                                                      |
| `data[].roundId`         | body | string                         | —      | RoundID is the round the cheque went into.                                                                    |
| `data[].shareClassId`    | body | string                         | —      | ShareClassID is the class shares were issued in, for a priced round.                                          |
| `data[].shares`          | body | integer (int64)                | —      | Shares is how many shares the investment bought; 0 when the round issues no equity at the time of investment. |
| `data[].stakeholderId`   | body | string                         | —      | StakeholderID is the investor.                                                                                |
| `data[].stakeholderName` | body | string                         | —      | StakeholderName is that investor's name.                                                                      |

Failure carries the platform error shape — see [Errors](https://docs.hanzo.ai/docs/errors).

## Examples

**CLI**

```bash
hanzo captable investments
```

**SDK**

**.ts**

```ts
import { Configuration, CaptableApi } from 'hanzoai';

const api = new CaptableApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.getCaptableInvestments();
```

**.py**

```python
from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import CaptableApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = CaptableApi(client).get_captable_investments()
```

**.go**

```go
cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.CaptableAPI.GetCaptableInvestments(context.Background()).Execute()
if err != nil {
	return err
}
```

**.rs**

```rust
use hanzo_client::apis::{configuration::Configuration, captable_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = captable_api::get_captable_investments(&cfg, Default::default()).await?;
```

**.java**

```java
import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.CaptableApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new CaptableApi(client).getCaptableInvestments();
```

**HTTP**

```bash
curl https://api.hanzo.ai/v1/captable/investments \
  -H "Authorization: Bearer $HANZO_API_KEY"
```

**MCP**

MCP reaches **captable** through the `captable` tool, which names its 30 operations with its own verbs — this one among them, under a name only MCP declares. `describe` explains any of them:

```bash
curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "describe",
         "arguments": {
           "op": "list_captable_classes"
         }
       }
     }'
```

---

[Captable API](https://docs.hanzo.ai/docs/openapi/captable) · [All Hanzo APIs](https://docs.hanzo.ai/docs/openapi) · [Interactive reference](https://docs.hanzo.ai/docs/openapi/reference)