Meta Llama model access: official registration and platforms

Putting a Meta Llama model on your own hardware looks easy until you meet the licence form, the 24-hour download link, and three separate platforms each claiming to be the simplest route. It becomes easy once you know the correct order of steps.

To obtain Meta Llama models, you must first sign up on the Meta website and agree to the model licence. After that you will receive a signed download link that stays valid for 24 hours. You may use this link to download the weights with Meta's official script, Hugging Face, or Ollama. The tool you choose depends on whether you need raw weights for fine-tuning or a quantised model for fast local performance.

Shipshape Data assists organisations in moving from AI experiments to production systems. Open-weight models like Llama are commonly used in this process. Teams frequently select these models to prototype while keeping data away from third-party APIs. They might also prefer to own and fine-tune a model instead of paying for access by the token. The initial steps include registering with Meta, accepting the licence terms, and downloading the weights to a local or controlled machine.

This guide details how to set up a local model from a blank slate. It outlines the preparation needed before requesting access and explains how to select among the available sizes and file formats. It details three methods for downloading the weights via Meta's script, Hugging Face, or Ollama. It also enumerates common errors that can delay the process. You should read the sections that apply to your specific setup and skip the rest, since only one download method is required.

What to sort out before you request access

Meta will not provide model weights until you register and accept the licence terms. Your computer also needs sufficient storage space for files that are tens of gigabytes in size. Complete these steps before you start. Most people who have to request access a second time did not prepare their systems first.

A Meta account and the licence

Visit the Meta Llama website and press the "Request Access" button. The form requires you to provide your name, email address, and the intended use of the model. Meta will then send you an email containing a signed URL that is valid for 24 hours, so wait to submit the request until your environment (Python, disk space, and everything else) is ready.

Use a work email address for your request if possible. Submissions from personal Gmail accounts often take longer to review than those from company domains. Meta has not provided an official explanation for this difference.

Llama 3, 3.1, and 3.2 each come with their own licence. When you obtain these models from Hugging Face, you must re-accept the licence even if you have already done so on the Meta site. Keep your confirmation email saved. The signed download link is linked to your registered email address and may not be shared with coworkers.

Read the licence carefully before building a commercial product with it. The Llama community licence permits most businesses to use it, yet it contains a particular clause for large platforms. If your product or service exceeds 700 million monthly active users, you must obtain a separate agreement from Meta. Most users do not reach that threshold. However, a client recently asked us to verify this before approving a project. It required five minutes to confirm they did not meet the requirement. That time proved well spent.

Required hardware

The model size you select determines the hardware requirements, and a broad selection is available. The 1B and 3B Llama 3.2 models operate on a modern laptop CPU with 8GB of RAM, but you will notice slower inference after only a few prompts. Models with more than 13B parameters need a dedicated GPU or a properly resourced cloud instance; trying to force a 70B model onto a laptop will simply waste an afternoon watching a fan spin.

Rough minimums by size, for reference:

• 1B to 3B parameters: 8GB RAM, 4GB GPU VRAM recommended
• 7B to 8B parameters: 16GB RAM, 8GB GPU VRAM recommended
• 13B to 14B parameters: 32GB RAM, 16GB GPU VRAM recommended
• 70B and above: 64GB+ RAM, 40GB+ VRAM, usually across multiple GPUs

Using a quantised GGUF version of a model with Ollama cuts the VRAM need to roughly half of those numbers. That lets a 13B or 70B model operate on a single standard consumer GPU rather than needing a server rack.

Not every GGUF file is quantised to the same degree, and the naming scheme can confuse users initially. Q8_0 remains near full precision and reduces the file size only minimally. Q5_K_M offers a reliable middle option: it is noticeably smaller while delivering output quality that remains adequate for most routine tasks. Q4_K_M is the choice most users settle on for local work; it is compact enough to operate on a mid-range GPU and still provides dependable output for chat and summarisation, although it begins to falter on exact reasoning tasks. Any model below Q4 is essentially intended only for verifying that a pipeline functions end to end, not for deployment in front of a user.

Required software installations

Meta's official download script needs Python 3.10 or a later version. You must also have Git and pip on your system path. If you intend to use Hugging Face, you should also install its command line interface:

pip install huggingface_hub
huggingface-cli login

To log in, you need a Hugging Face access token taken from the Access Tokens area in your Settings. The token must include at least "read" permission for gated repositories. Skipping this step causes the download to fail with a 403 error as soon as it starts. As a result, you won't know about the permissions problem until the download has already begun.

How to choose a model and a file format

Meta released the Llama 3 family in multiple sizes. The format you pick decides which tools will be usable later. Choosing the wrong format means you must download tens of gigabytes again. You can prevent this by reviewing the requirements for two minutes before starting.

Model size and parameter count

Parameter count represents the balance between capability and the amount of hardware required to run it. At the small end, 1B and 3B models, are quick, inexpensive to operate, and suitable for classification, summarisation, and simple chat. Tasks that require genuine reasoning, lengthy documents, or instruction-following in a technical field need at least the 8B tier, and frequently the 70B.

Most proof-of-concept builds start with Llama 3.1 8B Instruct. The model is already fine-tuned to follow instructions. You can obtain usable output right away without doing any fine-tuning yourself.

Original weights or GGUF

You will meet two formats in practice:

• Original weights (PyTorch .pth or .safetensors): these files are full-precision. You need them to fine-tune the model or to serve it with Hugging Face Transformers.
• GGUF: a quantised, single-file format designed for local inference using tools such as Ollama. These files are significantly smaller and operate effectively on a CPU or a consumer GPU while maintaining consistent quality.

If you need fast local iteration, obtain GGUF via Ollama. If you are working towards a fine-tuned production model, use the safetensors weights from Hugging Face instead.

Use the signed link to download directly from Meta

After your access request is approved, an email will be sent to you with a signed URL that remains valid for 24 hours. The email contains a functional script instead of a single large downloadable file. Meta supplies a shell script that retrieves the specific model you choose.

Clone the download script

The script can be found in Meta's public GitHub repository.

git clone https://github.com/meta-llama/llama-models.git
cd llama-models
chmod +x download.sh

Run the program and paste the URL

Run the script while in that directory. It will ask you to input the signed URL from your email and to choose a model identifier from the numbered list provided.

./download.sh

Paste the URL without any trailing spaces. A malformed URL results in a 403 error immediately. It is common to include extra spaces when copying text from an email client. When the system prompts you for the model identifier, enter the specific string for the size and variant you chose previously, such as meta-llama/Llama-3.1-8B-Instruct.

The script downloads the weights, a tokeniser, and a checksum file into a local folder. After the download finishes, verify that the files are correct before you continue:

md5sum -c checklist.chk

Each line must display OK. Any file marked FAILED is corrupted. To fix this, download that specific file again instead of restarting the entire process.

Downloading from Hugging Face

Most teams download Llama via Hugging Face because the platform is reliable. The hub contains all official Llama 3 releases and manages authentication through its command line interface. If a download is interrupted, it resumes from the point it stopped instead of starting again. This method is faster than using Meta's script, as long as you have already accepted the model's licence on the website.

Use the CLI to download the weights

Navigate to the model page, for example meta-llama/Llama-3.1-8B-Instruct, and click "Agree and access repository". Once permission is granted, download the weights straight to your computer.

huggingface-cli download meta-llama/Llama-3.1-8B-Instruct \
  --local-dir ./llama-3.1-8b-instruct \
  --local-dir-use-symlinks False

The --local-dir-use-symlinks False flag causes real files to be written instead of symlinks in the Hugging Face cache. This can be helpful when you need to mount the directory in a container or copy it to a cloud instance later.

In this context, a 403 error typically signals one of two problems. Your token might lack read access for gated repositories. Alternatively, you may have accepted the licence on the Meta website but not on the specific model page.

Ollama, for the quickest possible start

Ollama runs faster than the earlier options when you need to execute a quantised model locally without dealing with weight files. Download the software from the official website and execute this command:

ollama run llama3.1

This line handles storage, chooses a quantisation level, and hosts the model at http://localhost:11434/api/generate. Any application can be linked to this endpoint instead of writing custom inference code. This approach is the simplest way to prototype or test Llama's capabilities before building a complete pipeline.

Confirming the download is successful

Just because a download ends without an error message does not ensure the model will function. Based on our experience, teams frequently omit the verification step and then waste hours debugging application errors that actually stem from corrupted files or mismatched tokenisers. Run a smoke test right after the download finishes. Do it before writing any application code for the model.

Load the model and run a single prompt

The Hugging Face Transformers library loads the weights and checks that the model responds:

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_path = "./llama-3.1-8b-instruct"
tokeniser = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    torch_dtype=torch.float16,
    device_map="auto"
)

inputs = tokeniser("Explain what a transformer model is:", return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=100)
print(tokeniser.decode(outputs[0], skip_special_tokens=True))

torch_dtype=torch.float16 cuts memory consumption to half of what the default float32 setting uses. That decrease gives you additional headroom when your GPU is close to its VRAM limit.

If the model loads yet yields garbled output, check that the tokeniser and the weights were taken from the same directory. Employing a cached tokeniser from an earlier release together with newer weights triggers this particular problem. The issue is easy to miss since the model does not raise an error; it simply generates incoherent text.

Common errors you will encounter

We get numerous support tickets concerning this issue. Nearly all of them stem from four particular problems. Check these four items in the order listed before restarting the whole process.

• "model not found" (OSError) happens when the local path is wrong. Use an absolute path in from_pretrained rather than a relative one. This is required when you execute the code from a directory that differs from where you downloaded the files.
• CUDA out of memory: the model exceeds your VRAM capacity. Apply the bitsandbytes library with load_in_4bit=True, or select a smaller model.
• 403 Forbidden on download: your token lacks gated access. Re-accept the licence on the Hugging Face model page and generate a new token if the issue persists.
• md5sum FAILED: the download is either incomplete or corrupted. Remove that particular file and execute the download script again. There is no need to delete the whole folder.

Each issue has its own specific solution. You may be tempted to delete the whole configuration and restart when an error appears, yet this usually causes loss of a 24-hour access window without any benefit.

Running Llama in the cloud instead of using local hardware

You do not need local hardware or office GPU servers for every project. When building a tool for a team or when you prefer to avoid managing your own GPU infrastructure, you can access these models via managed endpoints on major cloud platforms. In such cases, the download process described earlier is unnecessary.

AWS delivers Llama models via Bedrock as a hosted API. The service charges per token and needs no infrastructure setup. Azure AI Foundry provides a comparable service on the Microsoft platform, and Google Cloud adds the Llama family to the Vertex AI Model Garden. These three providers manage the registration with Meta for the user. This lets you skip hardware planning and start using the model with an API key in a few minutes.

The trade-off is that you pay per token forever rather than making a one-time investment in GPU time. You also give up the ability to fine-tune weights directly or to run completely offline. A managed service is usually cheaper and simpler for a proof of concept or for workloads with unpredictable usage that would otherwise leave owned hardware idle. Keeping the weights and infrastructure is more practical for steady, high-volume workloads or when data residency rules forbid sending prompts to a third party. We recommend that clients prototype on a managed endpoint first. Only switch to self-hosting after the usage pattern is clear enough to choose the appropriate hardware size. Estimating these needs early often results in over-provisioning.

What comes after the download

You have now registered with Meta and chosen a model size and format that satisfy your requirements. You have also downloaded the weights via your preferred platform and confirmed that the model loads and works correctly. These actions finish the download and setup process.

The steps after the download are harder than the download itself. Integrating the model into a functional application demands substantial effort. Building a RAG pipeline for your documents, an internal knowledge tool, or an AI feature for an existing product entails architectural decisions, data preparation, and deployment planning. These tasks are more complex than merely saving model weights to a disk. We have observed teams get a model running locally in one afternoon and then spend three months attempting to serve it reliably at scale. This delay occurs because they did not plan for the second stage of the project.

That gap, between a working local model and something you can rely on in production, is where most of our work with clients starts. If you want a second opinion on your Llama setup, or help turning it into something production-ready, talk to us and we'll give you a straight answer on what's missing.

If you want this working inside your own systems rather than in a demo, that is what our AI development services are for.

Frequently asked questions