# Create fork

URL: https://docs.hanzo.ai/docs/openapi/provider/post-provider-github-fork

> Forks a granted repository.

`POST /v1/provider/github/fork`

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

|               |                                                |
| ------------- | ---------------------------------------------- |
| **Address**   | `https://api.hanzo.ai/v1/provider/github/fork` |
| **Method**    | `POST`                                         |
| **Operation** | `post_provider_github_fork`                    |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY`         |

Forks a granted repository.

GitHub's fork is ASYNCHRONOUS: it answers 202 with the target repo and
populates it in the background, and it answers the same 202 when the fork
already exists. So this reports what GitHub said rather than waiting — a call
that blocked until the clone finished would time out on a large repository and
tell the caller nothing it does not already know.

## Request

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

| Field  | In   | Type   | Required | Description                                                                                                      |
| ------ | ---- | ------ | -------- | ---------------------------------------------------------------------------------------------------------------- |
| `org`  | body | string | —        | Org is the GitHub account to fork INTO; empty forks to the installation's own account, which is the common case. |
| `repo` | body | string | —        | Repo is a repository the org's installation was GRANTED, by name.                                                |

## Response

| Status    | Body                   | Meaning |
| --------- | ---------------------- | ------- |
| `200`     | provider.githubForkOut | ok      |
| `default` | problem-details        | refused |

`200` body — 5 fields.

| Field            | In   | Type    | Always | Description                                                               |
| ---------------- | ---- | ------- | ------ | ------------------------------------------------------------------------- |
| `clone_url`      | body | string  | —      | CloneURL is the fork's https git remote.                                  |
| `default_branch` | body | string  | —      | DefaultBranch is the branch the fork checks out, inherited from upstream. |
| `existing`       | body | boolean | —      | Existing reports that the fork was already there.                         |
| `full_name`      | body | string  | —      | FullName is the fork's "owner/repo".                                      |
| `html_url`       | body | string  | —      | HTMLURL is the fork's page on github.com.                                 |

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

## Examples

**CLI**

```bash
hanzo provider github fork
```

**SDK**

**.ts**

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

const api = new ProviderApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.postProviderGithubFork({ org: "<org>", repo: "<repo>" });
```

**.py**

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

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = ProviderApi(client).post_provider_github_fork(org="<org>", repo="<repo>")
```

**.go**

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

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

**.rs**

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

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

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

**.java**

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

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

var result = new ProviderApi(client).postProviderGithubFork();
```

**HTTP**

```bash
curl -X POST https://api.hanzo.ai/v1/provider/github/fork \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "org": "<org>",
       "repo": "<repo>"
     }'
```

**MCP**

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

---

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