Create fork

Forks a granted repository.

POST /v1/provider/github/fork

Provider → · All API references → · Get started →

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.

Examples

CLI

SDK

HTTP

MCP

hanzo provider github fork

.ts

.py

.go

.rs

.java

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>" });

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

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
}

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?;

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();

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 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:

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 · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousCreate webhook — POST /v1/provider/forge/webhook NextCreate backfill — POST /v1/provider/github/issues/backfill