# List rules

URL: https://docs.hanzo.ai/docs/openapi/reward/get-reward-rules

> Lists what the rewards program pays for: every active rule of every active program, grouped by pillar (use, share, community, contribute, expert), each with what has to happen, the points, the badge or credit it awards, how often one person can earn it and whether staff verify each claim first.

`GET /v1/reward/rules`

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

|               |                                        |
| ------------- | -------------------------------------- |
| **Address**   | `https://api.hanzo.ai/v1/reward/rules` |
| **Method**    | `GET`                                  |
| **Operation** | `get_reward_rules`                     |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY` |

Lists what the rewards program pays for: every active rule of every active
program, grouped by pillar (use, share, community, contribute, expert), each with
what has to happen, the points, the badge or credit it awards, how often one person
can earn it and whether staff verify each claim first. Public: it needs no
credential, and it is the program's own list, so nothing else promises a reward.

## Request

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

## Response

| Status    | Body            | Meaning |
| --------- | --------------- | ------- |
| `200`     | reward.rulesOut | ok      |
| `default` | problem-details | refused |

`200` body — 16 fields.

| Field                            | In   | Type                  | Always | Description                                                                      |
| -------------------------------- | ---- | --------------------- | ------ | -------------------------------------------------------------------------------- |
| `pillars`                        | body | reward.pillarRules\[] | —      |                                                                                  |
| `pillars[].id`                   | body | string                | —      |                                                                                  |
| `pillars[].rules`                | body | reward.publicRule\[]  | —      |                                                                                  |
| `pillars[].rules[].badge`        | body | reward.publicBadge    | —      |                                                                                  |
| `pillars[].rules[].badge.id`     | body | string                | —      |                                                                                  |
| `pillars[].rules[].badge.name`   | body | string                | —      |                                                                                  |
| `pillars[].rules[].badge.rarity` | body | string                | —      |                                                                                  |
| `pillars[].rules[].creditCents`  | body | integer (int64)       | —      | CreditCents is the credit the rule grants, in cents.                             |
| `pillars[].rules[].event`        | body | string                | —      | Event says in plain words what has to happen for the rule to apply.              |
| `pillars[].rules[].id`           | body | string                | —      |                                                                                  |
| `pillars[].rules[].limits`       | body | string                | —      | Limits says in plain words how often one person can earn it.                     |
| `pillars[].rules[].name`         | body | string                | —      |                                                                                  |
| `pillars[].rules[].pillar`       | body | string                | —      | Pillar is the part of the program the rule belongs to.                           |
| `pillars[].rules[].points`       | body | integer (int64)       | —      | Points is what the rule adds to lifetime points when staff approve it.           |
| `pillars[].rules[].review`       | body | boolean               | —      | Review is whether staff verify each claim of the rule before it awards anything. |
| `pillars[].title`                | body | string                | —      |                                                                                  |

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

## Examples

**CLI**

```bash
hanzo reward rules
```

**SDK**

**.ts**

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

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

**.py**

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

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

**.go**

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

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

**.rs**

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

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

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

**.java**

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

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

var result = new RewardApi(client).getRewardRules();
```

The method above is the one at the current release of the document. `hanzoai@8.5.914` (npm) and `hanzoai@8.5.914` (PyPI) were generated from an earlier release, where this operation carried a different id, so it spells the method differently — regenerating the clients is what makes the two agree. [SDKs →](https://docs.hanzo.ai/docs/sdks)

**HTTP**

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

**MCP**

MCP reaches **reward** through the `reward` tool, which names its 7 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_reward_me_posts"
         }
       }
     }'
```

---

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