# Create scan

URL: https://docs.hanzo.ai/docs/openapi/reward/post-reward-me-posts-scan

> Reads your recent public posts on Bluesky, Mastodon, Reddit, Hacker News or DEV by the handle you give, and holds each that carries your own referral link, as pasting it would.

`POST /v1/reward/me/posts/scan`

> [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/me/posts/scan` |
| **Method**    | `POST`                                         |
| **Operation** | `post_reward_me_posts_scan`                    |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY`         |

Reads your recent public posts on Bluesky, Mastodon, Reddit, Hacker News or DEV by the
handle you give, and holds each that carries your own referral link, as pasting
it would. Every other network is pasted as an address: X, Medium and Hashnode are read when
pasted, and LinkedIn, TikTok, YouTube, Threads, Instagram and Facebook cannot be read
without your sign-in there, so staff decide those by hand. Asked at most three times an hour.

## Request

2 fields, body `application/json` (required).

| Field     | In   | Type   | Required | Description                                              |
| --------- | ---- | ------ | -------- | -------------------------------------------------------- |
| `handle`  | body | string | —        | Handle is your handle there; on Mastodon user\@instance. |
| `network` | body | string | —        | Network is bluesky, mastodon, reddit, hn or devto.       |

## Response

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

`200` body — 19 fields.

| Field                           | In   | Type               | Always | Description                                                                                                                                                              |
| ------------------------------- | ---- | ------------------ | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `held`                          | body | integer (int64)    | —      |                                                                                                                                                                          |
| `looked`                        | body | integer (int64)    | —      | Looked is how many of the recent posts were read, Held how many carried your link and are now held, and Skipped how many did not.                                        |
| `posts`                         | body | reward.postView\[] | —      |                                                                                                                                                                          |
| `posts[].checks`                | body | reward.Check\[]    | —      | Checks is every look at the post, oldest first.                                                                                                                          |
| `posts[].checks[].author_match` | body | string             | —      | AuthorMatch is whether the author is the member's linked identity: yes, no or unknown.                                                                                   |
| `posts[].checks[].fetched_at`   | body | string (date-time) | —      | FetchedAt is when the source was fetched.                                                                                                                                |
| `posts[].checks[].public`       | body | boolean            | —      | Public is whether the source is readable by anyone.                                                                                                                      |
| `posts[].checks[].ref_found`    | body | boolean            | —      | RefFound is whether the member's own ref code was found.                                                                                                                 |
| `posts[].checks[].status`       | body | integer (int64)    | —      | Status is the HTTP status the fetch answered.                                                                                                                            |
| `posts[].countsAt`              | body | string (date-time) | —      |                                                                                                                                                                          |
| `posts[].daysLeft`              | body | integer (int64)    | —      |                                                                                                                                                                          |
| `posts[].id`                    | body | string             | —      |                                                                                                                                                                          |
| `posts[].network`               | body | string             | —      |                                                                                                                                                                          |
| `posts[].note`                  | body | string             | —      | Note says why a post was removed.                                                                                                                                        |
| `posts[].since`                 | body | string (date-time) | —      | Since is when the post's week began; CountsAt when it counts, and DaysLeft the days until then.                                                                          |
| `posts[].status`                | body | string             | —      | Status is pending (held for its week, counts for nothing), verified (it stayed up and was put to staff), removed (it earns nothing) or review (staff decide it by hand). |
| `posts[].url`                   | body | string             | —      |                                                                                                                                                                          |
| `posts[].week`                  | body | string             | —      | Week is the ISO week the post was published in; a post in a later week can earn again.                                                                                   |
| `skipped`                       | body | integer (int64)    | —      |                                                                                                                                                                          |

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

## Examples

**CLI**

```bash
hanzo reward me posts scan
```

**SDK**

**.ts**

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

const api = new RewardApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.postRewardMePostsScan({ handle: "<handle>", network: "<network>" });
```

**.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).post_reward_me_posts_scan(handle="<handle>", network="<network>")
```

**.go**

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

resp, _, err := client.RewardAPI.PostRewardMePostsScan(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::post_reward_me_posts_scan(&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).postRewardMePostsScan();
```

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 -X POST https://api.hanzo.ai/v1/reward/me/posts/scan \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "handle": "<handle>",
       "network": "<network>"
     }'
```

**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)
