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

# Retrieve category set

GET https://api.ntropy.com/v3/categories/{id}

Retrieves the set of categories. Category sets are different per account holder type.

Reference: https://docs.ntropy.com/documentation/api/categories/get-category-set-v-3-categories-id-get

## Authentication

- `X-Api-Key` header (required) — API Key authentication via header

## Request

### Path parameters

- `id` (string, required)

## Response

### 200

Category set for the selected type of account holder

- `Categories_get_category_set_v3_categories__id__get_Response_200`

## Errors

### 422 Unprocessable Entity Error

Validation Error

- `detail` (list of ValidationError, optional)

## Types

### CategorySet

- `incoming` (list of string, required)
- `outgoing` (list of string, required)

### ValidationError

- `loc` (list of ValidationErrorLocItems, required)
- `msg` (string, required)
- `type` (string, required)

### ValidationErrorLocItems

## Examples

**Response**

```json
{
  "incoming": [
    "transfer from investment app",
    "transfer from stock broker",
    "transfer from crypto broker",
    "chargeback",
    "freelance income",
    "rideshare or delivery income",
    "paycheck",
    "benefits",
    "interest earned",
    "stock dividend"
  ],
  "outgoing": [
    "digital content and streaming",
    "vending machine",
    "reversal",
    "transfer to investment app",
    "transfer to stock broker",
    "transfer to crypto broker",
    "adjustment",
    "intra account transfer",
    "inter account transfer",
    "peer to peer transfer",
    "funeral service",
    "ATM withdrawal",
    "teller withdrawal"
  ]
}
```

**SDK Code**

```python Python SDK
from ntropy_sdk import SDK

sdk = SDK("cd1H...Wmhl")
categories = sdk.categories.get("consumer")
```

```javascript
const url = 'https://api.ntropy.com/v3/categories/id';
const options = {method: 'GET', headers: {'X-Api-Key': '<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.ntropy.com/v3/categories/id"

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

	req.Header.Add("X-Api-Key", "<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.ntropy.com/v3/categories/id")

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

request = Net::HTTP::Get.new(url)
request["X-Api-Key"] = '<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.ntropy.com/v3/categories/id")
  .header("X-Api-Key", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.ntropy.com/v3/categories/id', [
  'headers' => [
    'X-Api-Key' => '<apiKey>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.ntropy.com/v3/categories/id");
var request = new RestRequest(Method.GET);
request.AddHeader("X-Api-Key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["X-Api-Key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.ntropy.com/v3/categories/id")! 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()
```