# Author

URL: https://docs.hanzo.ai/docs/openapi/author

> A royalty for open-source work: your repo runs, you get paid.

Also for this capability: **API** · [CLI](https://docs.hanzo.ai/docs/cli/author) · [MCP](https://docs.hanzo.ai/docs/mcp-tools/author) · [SDKs](https://docs.hanzo.ai/docs/sdks)

A royalty for open-source work: your repo runs, you get paid.

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

|                |                                        |
| -------------- | -------------------------------------- |
| **Base URL**   | `https://api.hanzo.ai`                 |
| **Operations** | 5                                      |
| **Auth**       | `Authorization: Bearer $HANZO_API_KEY` |

## Specification

Specification pending — no HIP in [hanzoai/hips](https://github.com/hanzoai/hips) declares `capability: author` yet. What this capability serves is below, from the API document; what it is — the store it owns, how it meters, what it publishes — is written as a HIP under HIP-0139.

## Four surfaces

| Surface  | Reaches this capability as                     | Coverage                                                                  |
| -------- | ---------------------------------------------- | ------------------------------------------------------------------------- |
| **REST** | `author` at its own prefix                     | 5 operations                                                              |
| **CLI**  | `hanzo author …`                               | 5 of 5                                                                    |
| **SDK**  | `AuthorApi` in every published client          | 5 methods                                                                 |
| **MCP**  | tool `author` on `https://api.hanzo.ai/v1/mcp` | 5 operations, 1 under the document's own id — ask `describe` for the rest |

## Quickstart

```bash
export HANZO_API_KEY=sk-...   # console.hanzo.ai → API keys
```

Then the first call — a read that needs nothing but the key. `GET /v1/author`, operation `get_author`:

**CLI**

```bash
hanzo author get
```

**SDK**

**.ts**

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

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

**.py**

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

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

**.go**

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

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

**.rs**

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

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

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

**.java**

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

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

var result = new AuthorApi(client).getAuthor();
```

**HTTP**

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

**MCP**

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

Answers `200` with `object` — ok.

## Endpoints

| Endpoint                                                                                                 | What it does                                                                                                                                                                                                                                                                                 |
| -------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [`GET /v1/author/basis`](https://docs.hanzo.ai/docs/openapi/author/get-author-basis)                     | Returns the AUDIT TRAIL behind the caller's own royalty: every ledger row with the spend it was computed from, the share applied at the time, the platform's matching half, whether each row satisfies the formula, and the attribution edges that already existed when the row was written. |
| [`POST /v1/author/connect`](https://docs.hanzo.ai/docs/openapi/author/post-author-connect)               | Enrols the caller's org in the author program at status "connected" and returns its enrolment, including the verify code the file method needs.                                                                                                                                              |
| [`POST /v1/author/deploys/record`](https://docs.hanzo.ai/docs/openapi/author/post-author-deploys-record) | Records that the caller's org deployed a project built from a source repository, which is the edge that makes an author's work earn royalty.                                                                                                                                                 |
| [`POST /v1/author/repos/verify`](https://docs.hanzo.ai/docs/openapi/author/post-author-repos-verify)     | Proves that the caller owns a repository — or a whole OWNER — and records the claim, which is what makes deploys of that code earn royalty.                                                                                                                                                  |
| [`GET /v1/author`](https://docs.hanzo.ai/docs/openapi/author/get-author)                                 | Returns the caller's author-program dashboard: enrolment status, linked forge login, verified repositories and owner-wide claims, recorded deploys, accrued / pending / paid royalty, and the payout history.                                                                                |

---

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