Hugging Face

Veri can push trained weights straight to your Hugging Face account. Connect your account once, then push either way:

	Push a finished model	Push automatically when a job finishes
When	Any time, on a model in your library	At the end of the training run
How	`veri models push-hf` (CLI), dashboard, or API	`hf_push` on the training job
Needs a new training run	No	Yes, it is part of the run

If you just want your trained weights on Hugging Face, use the first one: it is a single command and works on anything already in your model library. The second exists so a long run can hand off its result without you coming back to it. The pushed repo link is surfaced everywhere the model appears:

Dashboard: a “View on Hugging Face” button on the job page.
API / SDK: the hf_repo_url field on the training job object.

Connect your account

Create a token with write scope at huggingface.co/settings/tokens, then connect it one of three ways. Veri validates the token against Hugging Face when you save it, so a bad token fails here instead of at the end of a training run.

CLI
Dashboard
SDK

veri hf set
# Hugging Face token (input hidden): ...

Check or remove the connection any time:

veri hf status
veri hf remove

from veri_sdk import Client

client = Client()
client.integrations.set_huggingface(token="hf_...")

client.integrations.get_huggingface()     # {"configured": true, "username": "you"}
client.integrations.delete_huggingface()  # disconnect

Push a finished model

Models already in your model library (finished training jobs you saved, or cached Hugging Face imports) can be pushed at any time, with no training run required. The upload happens server-side; nothing downloads to your machine. Save a finished job’s checkpoint into the library first if it is not there yet:

veri models save <job_id> --name my-model

CLI
Dashboard
API

veri models push-hf model_abc123 --repo your-namespace/my-model
# Export exp_... started: model_abc123 -> your-namespace/my-model
#   uploading: 40% ...
# Pushed: https://huggingface.co/your-namespace/my-model

Add --public to create a public repo, --no-wait to return immediately.

curl -X POST https://api.veri.studio/v1/models/{model_id}/push-to-hf \
  -H "Authorization: Bearer $VERI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"repo": "your-namespace/my-model", "private": true}'

# poll until status is terminal; hf_repo_url carries the repo link
curl -s https://api.veri.studio/v1/hf_exports/{export_id} \
  -H "Authorization: Bearer $VERI_API_KEY"

One export per model/repo pair runs at a time, and up to two exports can run concurrently per account. A failed or cancelled export leaves your model untouched; retrying re-uploads only what changed.

Push automatically when a job finishes

Opt in on the job itself with a target repo and the artifact you want. artifact is required and picks what lands in the repo:

merged: standalone weights, loadable with from_pretrained alone. For LoRA runs, Veri merges the adapter into the base model before uploading.
adapter: the LoRA adapter only (requires a LoRA job, i.e. lora_rank set). Small upload; load it with PEFT on top of the base model.

Repos default to private; set private = false to publish.

Config file
SDK
API

[method]
type = "grpo"
lora_rank = 16

[huggingface]
repo = "your-namespace/my-tuned-model"
artifact = "adapter"        # or "merged"
private = true

Submit as usual with veri run.

job = client.training_jobs.create(
    base_model="Qwen/Qwen3-4B",
    dataset_id="ds_...",
    reward_source=open("reward.py").read(),
    gpu_type="A100-80GB",
    gpu_count=1,
    hf_push={
        "repo": "your-namespace/my-tuned-model",
        "artifact": "merged",
        "private": True,
    },
)
job.wait()
print(job.hf_repo_url)  # https://huggingface.co/your-namespace/my-tuned-model

hf_push is a field on Create training job; the pushed repo comes back as hf_repo_url on the job object.

curl -X POST https://api.veri.studio/v1/training_jobs \
  -H "Authorization: Bearer $VERI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "base_model": "Qwen/Qwen3-4B",
    "dataset_id": "ds_...",
    "reward_source": "def reward(completions, answer, **kwargs):\n    ...",
    "output_name": "my-tuned-model",
    "gpu": {"gpu_type": "A100-80GB", "gpu_count": 1},
    "hf_push": {
      "repo": "your-namespace/my-tuned-model",
      "artifact": "merged",
      "private": true
    }
  }'

# after completion:
curl -s https://api.veri.studio/v1/training_jobs/{job_id} \
  -H "Authorization: Bearer $VERI_API_KEY" | jq -r .hf_repo_url

Requests that can’t succeed are rejected at submit, not after a paid run: an unconnected account, a malformed repo id, or artifact = "adapter" on a job without lora_rank all fail immediately with a clear message.

The push is supported for managed grpo, grpo_harness, sft_text, and dpo jobs. Custom-script jobs own their training loop and can push from the script itself; sft_video_gen is not supported yet.

What happens at the end of the run

The trained checkpoint is saved and uploaded to Veri storage as usual. The push is additive, and your checkpoint stays downloadable from Veri either way.
For merged on a LoRA run, the adapter is merged into the base model on the training machine.
Veri creates the repo if it doesn’t exist (honoring private) and uploads the artifact.
The job records hf_repo_url on success.

A failed push never fails the job: training results are kept and the skip reason appears in the job logs.

How your token is handled

Stored encrypted at rest, scoped to your account. The API never returns it.
Delivered to the training machine at runtime over a job-scoped authenticated channel, only for jobs that opted into the push; it is never written into job config files or logs.
veri hf remove disconnects immediately: jobs submitted afterwards can no longer push.

Get started

Training

Deployments

CLI

Volumes

Webhooks

Connect your account

Push a finished model

Push automatically when a job finishes

What happens at the end of the run

How your token is handled

​Connect your account

​Push a finished model

​Push automatically when a job finishes

​What happens at the end of the run

​How your token is handled

Connect your account

Push a finished model

Push automatically when a job finishes

What happens at the end of the run

How your token is handled