How do I sign up for Oxen.ai and create my first private repo?

Most teams hit the same wall: you finally have a promising model prototype, but your training data lives in random S3 buckets, local folders, and ad-hoc zips. You can’t answer “which data trained which model?” and you definitely can’t reproduce last week’s run. Signing up for Oxen.ai and creating your first private repo is how you start fixing that—by versioning datasets and model weights like code from day one.

Quick Answer: To sign up for Oxen.ai, go to oxen.ai, click “Sign up,” and create an account using email/password, magic link, or GitHub. Once you’re logged in, create a new repository and mark it private—your Explorer (Free Forever) plan includes up to 5 private repos with up to 3 collaborators each, so you can immediately start versioning your first dataset or model weights.

Why This Matters

If you care about moving from prototype to production, you need a clear, repeatable path from dataset → fine-tuned model → deployed endpoint. That starts with a private repo where you can safely store and version your training data, evaluation sets, and model artifacts without leaking anything sensitive.

Using Oxen.ai, you get Git-like workflows that actually work for large, multi-modal assets. Signing up and creating your first private repo is the first step to owning your AI stack instead of pushing one-off zips to S3 and hoping nobody overwrites them.

Key Benefits:

• Start with real privacy: Your first private repo lets you safely store non-public datasets, labels, and model weights with access limited to your team.
• Version every asset: Track changes to datasets, annotations, and models over time so you can always answer “what changed and why.”
• Unlock the full loop: Once your private repo is set up, you can fine-tune models and deploy serverless endpoints directly on top of your versioned data.

Core Concepts & Key Points

Concept	Definition	Why it's important
Oxen.ai account	Your user identity on Oxen.ai, created via email/password, magic link, or GitHub login.	Needed to create repositories, manage access, and connect datasets to fine-tuned models and endpoints.
Private repository	A versioned storage space for datasets, model weights, and other large AI artifacts that is only visible to you and invited collaborators.	Keeps sensitive data safe while still giving your team Git-like history, branching, and collaboration.
Explorer plan limits	Oxen.ai’s Free Forever tier: unlimited public repos, plus 5 private repos (max 3 collaborators), 50 GB storage, 50 GB transfer.	Lets you start building serious AI projects without paying upfront, while keeping an eye on storage and privacy constraints.

How It Works (Step-by-Step)

You’ll go through three basic phases: sign up, log in, then create and configure your first private repo.

1. Sign Up for Oxen.ai

   • Visit https://www.oxen.ai in your browser.
   • Click Sign up (or Get Started / Get Started for Free! on the pricing page).
   • Choose how you want to register:
     • Email + password: Enter a username or email address, choose a secure password, and submit.
     • Magic link: Provide your email, then click the login link Oxen.ai sends to your inbox.
     • GitHub: Click Continue with GitHub and authorize Oxen.ai when prompted.
   • Confirm any verification email if requested. Once complete, you’ll land in your Oxen.ai workspace on the Explorer (Free Forever) plan unless you upgrade.

2. Log In to Your New Account

   • Go to the Oxen login page and click Log in.
   • Pick your login method:
     • Log in with password: Enter your username or email and password, then click Log in with password.
     • Magic link: Click the magic-link option, enter your email, and open the link sent to you.
     • GitHub: Click Continue with GitHub to sign in with your GitHub account.
   • If you forgot your password, use Forgot password? Recover to reset it.
   • After logging in, you’ll see your dashboard with any repos you own or have access to (initially, this will be empty).

3. Create Your First Private Repository

   • From the dashboard, look for a New Repository, Create Repo, or similar button.
   • Fill in the core details:
     • Repository name: Pick something meaningful like image-classification-dataset, video-captioning-training, or model-weights-v1.
     • Description: Briefly describe what will live here (e.g., “Main training and eval data for our product search model”).
   • Set Visibility to Private:
     • This ensures only you and explicitly invited collaborators can see or modify the repo.
   • Confirm repo creation.
   • You now have a private, versioned space to:
     • Upload datasets (images, text, audio, video, labels).
     • Store fine-tuning datasets, evaluation sets, or model weights.
     • Collaborate with up to 3 total collaborators on the Explorer plan.

4. Invite Collaborators (Optional but Recommended)

   • Open your new private repo and find the Settings, Collaborators, or Access section.
   • Add teammates by username or email (depending on the UI).
   • For each collaborator, choose the right permission level:
     • Read-only: For stakeholders who just need to review data.
     • Write: For engineers and annotators who will push updates.
   • Remember: on the Explorer plan, you can have up to 3 collaborators on private repos, which is usually enough for a core project pod.

5. Upload Your First Dataset or Artifact

   • In your private repo, use the Upload or Add files area to:
     • Upload raw data (e.g., .jpg, .png, .txt, .json, .wav, .mp4).
     • Upload labels or annotations (e.g., CSV, JSON, parquet).
     • Upload model weights or checkpoints.
   • Oxen.ai is designed for large, multi-modal assets, so you get version control without fighting git lfs or timing out on huge pushes.
   • Commit your changes with a clear message (e.g., “Initial image dataset v0.1”).
   • From here, you can:
     • Iterate on the dataset (cleaning, labeling, filtering).
     • Use Oxen.ai’s fine-tuning workflows to train a custom model from the repo.
     • Deploy your fine-tuned model to a serverless endpoint in one click.

Common Mistakes to Avoid

• Mistake 1: Using public repos for sensitive data

  It’s tempting to click through and accept the default repo visibility. If you’re working with non-public user data, proprietary images, or internal product text, you must keep it private.

  How to avoid it: Double-check the Visibility setting when creating a repo. Explicitly select Private before clicking create. If you accidentally made it public, change the visibility in repo settings immediately and rotate any downstream credentials if needed.

• Mistake 2: Treating your private repo like a dump folder

  A private repo is not just a giant zip file with no structure. If you throw everything into one directory without versioning discipline, you lose the main benefits: traceability, reproducibility, and clean iteration.

  How to avoid it:

  • Organize by purpose: train/, val/, test/, raw/, processed/.
  • Commit in logical increments with clear messages (e.g., “Added 5k labeled cat images,” “Removed low-resolution samples,” “Updated labels after QA pass”).
  • Tag important versions (v0.1, v0.2, v1.0) as you prepare training runs so you always know which dataset version trained which model.

Real-World Example

Imagine you’re building a product search feature for an e-commerce app. You’ve got internal product photos, SEO text, and user-generated content—all of it non-public, all of it messy.

Here’s how you might use Oxen.ai in practice:

• You sign up for Oxen.ai, log in with GitHub, and start on the Explorer (Free Forever) plan.
• You create a private repo called product-search-multimodal-dataset with the description: “Images + titles + descriptions + click data for product search ranking.”
• You upload your first batch of product images and text descriptions, organizing them into raw/ and labels/.
• Your data scientist and product manager join as collaborators to:
  • Review examples that will influence model behavior.
  • Mark edge cases and label corrections directly through dataset updates.
• Once the data looks solid, you fine-tune a model using Oxen.ai’s zero-code flow, pointing the training job at the curated dataset in that private repo.
• You then deploy the fine-tuned model to a serverless endpoint in a click, and your product team starts A/B testing it in the app.

All the while, you can answer the question that usually causes pain in retro meetings: “Which version of the data trained the model currently in production?” The answer lives right there in your private Oxen.ai repo history.

Pro Tip: Before your first real training run, tag the dataset version in your private repo (e.g., dataset_v1.0_train) and record that tag in your experiment notes. When the model performs well, you can always reproduce it—or safely iterate from that exact baseline.

Summary

Signing up for Oxen.ai and creating your first private repo is less about filling out a form and more about committing to data discipline early. With a free Explorer account, you can:

• Register via email, magic link, or GitHub.
• Create up to 5 private repositories with up to 3 collaborators.
• Version every dataset and model artifact with Git-like history, even when files are large and multi-modal.

Once your private repo is in place, you’re ready to move through the full loop—curate your data, fine-tune a custom model, deploy it to a serverless endpoint, and keep iterating with reproducible, inspectable history.

Next Step

Get Started