> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.aventure.vc/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.aventure.vc/_mcp/server.

# List entity filter options

GET https://api.aventure.vc/v1/entities/filters

Get available filter options

Reference: https://docs.aventure.vc/api-reference/a-venture-api/entity-filters

## Authentication

- `X-Client-Secret` header (required) — Client secret for read-only service-to-service access (no writes)

## Request

### Query parameters

- `typeGroup` (enum, optional) — Type group for default filter scope. Ignored when typeRecord is provided.
  - Allowed values: `Organization`, `Investor`
- `typeRecord` (string, optional) — Filter by entity type (Company, Investor, etc.)
- `includePrivate` (boolean, optional, default: false) — Include governed expanded values
- `includeDistribution` (boolean, optional, default: false) — Include range distribution charts
- `distributionKey` (list of string, optional) — Comma-separated or repeated filter keys for chart distribution (for example amountRaised,totalRaised)

## Response

### 200

OK

- `arrayFilterEntry` (list of object, required) — Array filter entries
  - `chart` (list of object, required) — Chart filter values
    - `amount` (long, required) — Amount
    - `end` (long, required) — Exclusive bucket end value
    - `start` (long, required) — Inclusive bucket start value
  - `choiceOption` (list of object, required) — Choice option filter values
    - `label` (string, required) — Display label for the option
    - `value` (string, required) — Canonical option value
    - `scope` (object, optional, nullable) — Optional numeric scope for the option
      - `max` (long, optional, nullable) — Maximum scope value
      - `min` (long, optional, nullable) — Minimum scope value
  - `controlType` (enum, required) — Control type used to render the filter
    - Allowed values: `checkbox`, `range`, `currencyRange`, `dateRange`
  - `filterKey` (string, required) — Canonical filter key
  - `label` (string, required) — Display label for the filter
  - `choiceOptionTotal` (integer, optional, nullable) — Total eligible choice option values for this filter
  - `choiceOptionTruncated` (boolean, optional, nullable) — Whether additional eligible choices exist beyond choiceOption
  - `filterMeta` (object, optional, nullable) — Optional entity-specific filter metadata
    - `ui` (object, optional, nullable) — UI metadata for rendering entity filter controls
      - `headquartersOption` (object, optional, nullable) — Headquarters option hierarchy
        - `country` (list of object, required) — Countries with their states and cities
          - `country` (string, required) — Country name
          - `state` (list of object, required) — States within the country
            - `city` (list of string, required) — Cities within the state; empty when only states were requested
            - `state` (string, required) — State name
  - `scope` (object, optional, nullable) — Optional numeric scope for the filter
    - `max` (long, optional, nullable) — Maximum scope value
    - `min` (long, optional, nullable) — Minimum scope value
- `rangeFilterEntry` (list of object, required) — Range filter entries
  - `chart` (list of object, required) — Chart filter values
    - `amount` (long, required) — Amount
    - `end` (long, required) — Exclusive bucket end value
    - `start` (long, required) — Inclusive bucket start value
  - `choiceOption` (list of object, required) — Choice option filter values
    - `label` (string, required) — Display label for the option
    - `value` (string, required) — Canonical option value
    - `scope` (object, optional, nullable) — Optional numeric scope for the option
      - `max` (long, optional, nullable) — Maximum scope value
      - `min` (long, optional, nullable) — Minimum scope value
  - `controlType` (enum, required) — Control type used to render the filter
    - Allowed values: `checkbox`, `range`, `currencyRange`, `dateRange`
  - `filterKey` (string, required) — Canonical filter key
  - `label` (string, required) — Display label for the filter
  - `choiceOptionTotal` (integer, optional, nullable) — Total eligible choice option values for this filter
  - `choiceOptionTruncated` (boolean, optional, nullable) — Whether additional eligible choices exist beyond choiceOption
  - `filterMeta` (object, optional, nullable) — Optional entity-specific filter metadata
    - `ui` (object, optional, nullable) — UI metadata for rendering entity filter controls
      - `headquartersOption` (object, optional, nullable) — Headquarters option hierarchy
        - `country` (list of object, required) — Countries with their states and cities
          - `country` (string, required) — Country name
          - `state` (list of object, required) — States within the country
            - `city` (list of string, required) — Cities within the state; empty when only states were requested
            - `state` (string, required) — State name
  - `scope` (object, optional, nullable) — Optional numeric scope for the filter
    - `max` (long, optional, nullable) — Maximum scope value
    - `min` (long, optional, nullable) — Minimum scope value
- `filtersMeta` (object, optional, nullable) — Metadata for the generated filter option set
  - `defaultOptionLimit` (integer, required) — Default maximum option count
  - `distributionKey` (list of string, required) — Filter keys that include distribution data
  - `generatedAt` (datetime, required) — Generation timestamp
  - `includeDistribution` (boolean, required) — Whether distribution data is included
  - `includePrivate` (boolean, required) — Whether private filter options are included
  - `includedTypeRecord` (list of string, required) — Entity type records included in the filter payload
  - `optionMode` (enum, required) — Option mode used to generate option lists
    - Allowed values: `TOP_RESULTS`, `FULL_RESULTS`
  - `requestedTypeGroup` (string, required) — Requested entity type group
  - `defaultTypeGroup` (enum, optional) — Default type group
    - Allowed values: `Organization`, `Investor`
  - `typeGroupMembership` (list of object, optional) — Type group membership filter values
    - `typeGroup` (enum, required) — Canonical entity type groups for boundary-level scope selection.
      - Allowed values: `Organization`, `Investor`
    - `typeRecord` (list of enum, required)
      - Allowed values: `Company`, `Investment Firm`, `Fund`, `Nonprofit`, `Government`, `Organization`, `Business Line`, `Product`, `Service`

## Examples

**Response**

```json
{
  "arrayFilterEntry": [
    {
      "chart": [
        {
          "amount": 1,
          "end": 1,
          "start": 1
        }
      ],
      "choiceOption": [
        {
          "label": "string",
          "value": "string",
          "scope": {
            "max": 1,
            "min": 1
          }
        }
      ],
      "controlType": "checkbox",
      "filterKey": "string",
      "label": "string",
      "choiceOptionTotal": 1,
      "choiceOptionTruncated": true,
      "filterMeta": {
        "ui": {
          "headquartersOption": {
            "country": [
              {
                "country": "string",
                "state": [
                  {
                    "city": [
                      "string"
                    ],
                    "state": "string"
                  }
                ]
              }
            ]
          }
        }
      },
      "scope": {
        "max": 1,
        "min": 1
      }
    }
  ],
  "rangeFilterEntry": [
    {
      "chart": [
        {
          "amount": 1,
          "end": 1,
          "start": 1
        }
      ],
      "choiceOption": [
        {
          "label": "string",
          "value": "string",
          "scope": {
            "max": 1,
            "min": 1
          }
        }
      ],
      "controlType": "checkbox",
      "filterKey": "string",
      "label": "string",
      "choiceOptionTotal": 1,
      "choiceOptionTruncated": true,
      "filterMeta": {
        "ui": {
          "headquartersOption": {
            "country": [
              {
                "country": "string",
                "state": [
                  {
                    "city": [
                      "string"
                    ],
                    "state": "string"
                  }
                ]
              }
            ]
          }
        }
      },
      "scope": {
        "max": 1,
        "min": 1
      }
    }
  ],
  "filtersMeta": {
    "defaultOptionLimit": 1,
    "distributionKey": [
      "string"
    ],
    "generatedAt": "2024-01-15T09:30:00Z",
    "includeDistribution": true,
    "includePrivate": true,
    "includedTypeRecord": [
      "string"
    ],
    "optionMode": "TOP_RESULTS",
    "requestedTypeGroup": "string",
    "defaultTypeGroup": "Organization",
    "typeGroupMembership": [
      {
        "typeGroup": "Organization",
        "typeRecord": [
          "Company"
        ]
      }
    ]
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.aventure.vc/v1/entities/filters"

querystring = {"includeDistribution":"false","includePrivate":"false"}

headers = {"X-Client-Secret": "<apiKey>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

```javascript
const url = 'https://api.aventure.vc/v1/entities/filters?includeDistribution=false&includePrivate=false';
const options = {method: 'GET', headers: {'X-Client-Secret': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.aventure.vc/v1/entities/filters?includeDistribution=false&includePrivate=false"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("X-Client-Secret", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.aventure.vc/v1/entities/filters?includeDistribution=false&includePrivate=false")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["X-Client-Secret"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.aventure.vc/v1/entities/filters?includeDistribution=false&includePrivate=false")
  .header("X-Client-Secret", "<apiKey>")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.aventure.vc/v1/entities/filters?includeDistribution=false&includePrivate=false', [
  'headers' => [
    'X-Client-Secret' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.aventure.vc/v1/entities/filters?includeDistribution=false&includePrivate=false");
var request = new RestRequest(Method.GET);
request.AddHeader("X-Client-Secret", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["X-Client-Secret": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.aventure.vc/v1/entities/filters?includeDistribution=false&includePrivate=false")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```