Get sync

Returns one sync by id.

GET /v1/sync/{id}

Sync → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/sync/{id}`
Method	`GET`
Operation	`get_sync_by_id`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Returns one sync by id. It is org-scoped: an id belonging to another tenant is the same 404 an unknown id gives, so a probe learns nothing about what exists.

Request

1 field.

Field	In	Type	Required	Description
`id`	path	string	yes	ID is the sync to act on, from the path.

Response

Status	Body	Meaning
`200`	sync.syncView	ok
`default`	problem-details	refused

200 body — 24 fields.

Field	In	Type	Always	Description
`actor`	body	string	—	Actor is the identity a reconcile writes AS.
`createdAt`	body	string	—	CreatedAt is when the link was first declared, RFC3339 in UTC.
`direction`	body	string	—	Direction is which way work flows: "both", "pull" (target ← source), "push" (source → target), or "off" — which keeps the link declared and moves nothing.
`id`	body	string	—	ID is the link's handle, derived from its source and target — which is what makes re-declaring the same pair an update rather than a duplicate.
`kind`	body	string	—	Kind is what is being synced.
`native`	body	sync.nativeView	—
`native.advancedAt`	body	string	—	AdvancedAt is when an import or a push last moved one of its refs, RFC3339 in UTC.
`native.branch`	body	string	—	Branch is the forge's default branch, which an import sets to the upstream's once that branch has landed.
`native.clone`	body	string	—	Clone is the https address to clone it from.
`native.sizeBytes`	body	integer (int64)	—	SizeBytes is the repository's size on the forge, in bytes.
`native.ssh`	body	string	—	SSH is the ssh address to clone it from, when the forge serves one.
`native.status`	body	string	—	Status is one of "synced" (the forge holds it and no ref is in conflict), "conflict" (an upstream ref diverged and the forge kept its own history), "pending" (the forge does not hold it yet) or "paused" (the link's direction is off).
`native.url`	body	string	—	URL is the repository's page on the forge.
`scope`	body	string	—	Scope is "repo" for a link to one repository, or "account" for a link to a whole GitHub account, which declares a repo link for every repository the account holds — the ones created later included.
`source`	body	sync.endpointView	—
`source.connector`	body	string	—	Connector names a connected account from the org's connector registry, when the endpoint reaches its provider through one.
`source.locator`	body	string	—	Locator addresses the thing INSIDE that provider, in the provider's own terms — an https clone URL for a hosted forge, a bare repository name for hanzo-git.
`source.provider`	body	string	—	Provider is the concrete integration: "github", "gitlab" or "hanzo-git".
`target`	body	sync.endpointView	—
`target.connector`	body	string	—	Connector names a connected account from the org's connector registry, when the endpoint reaches its provider through one.
`target.locator`	body	string	—	Locator addresses the thing INSIDE that provider, in the provider's own terms — an https clone URL for a hosted forge, a bare repository name for hanzo-git.
`target.provider`	body	string	—	Provider is the concrete integration: "github", "gitlab" or "hanzo-git".
`trigger`	body	string	—	Trigger is what starts a reconcile: "webhook" (the provider tells us), "poll" (we ask on a schedule), or "manual" (only an explicit call).
`updatedAt`	body	string	—	UpdatedAt is bumped by every reconcile, so it reads as the LAST-SYNCED time rather than the last edit.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo sync get <id>

.ts

.py

.go

.rs

.java

import { Configuration, SyncApi } from 'hanzoai';

const api = new SyncApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.getSyncById({ id: 'id' });

from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import SyncApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = SyncApi(client).get_sync_by_id(id='id')

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

resp, _, err := client.SyncAPI.GetSyncById(context.Background()).Execute()
if err != nil {
	return err
}

use hanzo_client::apis::{configuration::Configuration, sync_api};

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

let result = sync_api::get_sync_by_id(&cfg, Default::default()).await?;

import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.SyncApi;

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

var result = new SyncApi(client).getSyncById();

curl https://api.hanzo.ai/v1/sync/<id> \
  -H "Authorization: Bearer $HANZO_API_KEY"

Tool sync, op get_sync_by_id — POST the JSON-RPC envelope to https://api.hanzo.ai/v1/mcp.

curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "sync",
         "arguments": {
           "op": "get_sync_by_id",
           "input": {
             "id": "<id>"
           }
         }
       }
     }'

Sync API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousDelete sync NextList sync