docs.baseten.co

If you're new to Ahrefs and want to run your first SEO audit, the fastest path is: open Site Explorer, enter your target URL, review the Overview for a health snapshot, then dig into Organic Keywords, Top Pages, and Site Audit to find specific problems. From there, build a short prioritized to-do list instead of trying to fix everything at once.

This tutorial walks through that workflow using a realistic starting scenario, explains what the numbers mean, and shows how to turn findings into actions.

Before You Start: Pick a Narrow Scope

A common beginner mistake is auditing an entire large website on day one. The reports become overwhelming, and you can't tell which issues matter.

Instead, choose one of these starting points:

• A single important page (your homepage or a key product/service page)
• A small site (under ~50 pages, e.g., a personal blog or small business site)
• One section of a bigger site (e.g., /blog/)

For this tutorial, assume you're auditing a small business site with about 30 pages. The same steps scale up later.

You'll need an Ahrefs account to follow along. Ahrefs offers paid plans, and pricing and feature limits change over time, so check the current Pricing page for what's included in each tier before committing.

Step 1: Enter Your Target in Site Explorer

Site Explorer is Ahrefs' core tool for analyzing any website or URL.

1. Open Site Explorer from the top navigation.
2. In the search box, paste your domain (e.g., example.com).
3. Choose the Exact URL or Domain mode depending on scope. For a full-site view, use Domain or Prefix; for a single page, use Exact URL.
4. Press Enter.

You'll land on the Overview report. Don't try to absorb everything — focus on four numbers first.

Reading the Overview Snapshot

Important caveat: Ahrefs' traffic and keyword numbers are estimates based on its own data. They won't match Google Search Console or your analytics exactly. Treat them as directional, not absolute.

Step 2: See What You Already Rank For

Go to Organic Keywords in the left sidebar. This shows queries where your site appears in search results.

Sort by Traffic (descending) to see which pages bring the most estimated visitors. Then look for:

• Keywords ranking in positions 4–15 — these are often the easiest wins. A small content or on-page improvement can push them onto page one.
• Keywords with high volume but low position — potential opportunities if the topic is relevant.
• Irrelevant keywords — if you rank for something off-topic, it may signal thin or mismatched content.

Write down 5–10 of the position 4–15 keywords. These become your first optimization targets.

Step 3: Find Your Best and Weakest Pages

Open Top Pages. This ranks your URLs by estimated organic traffic.

Look for two things:

1. Your top performers — understand what topics and formats work. Can you create more content like this?
2. Pages with traffic but poor rankings — these may need on-page fixes (title, headings, internal links).

If a page gets zero traffic and targets a topic you care about, it's a candidate for a rewrite or consolidation.

Step 4: Run a Technical Site Audit

Now move to Site Audit. This crawls your site and flags technical and on-page issues.

1. Click Site Audit → New project.
2. Enter your domain and set crawl settings (default is usually fine for a small site).
3. Start the crawl and wait for it to finish.

Once complete, you'll see a Health Score and a list of issues grouped by category.

Which Issues to Fix First

Not all issues are equal. Prioritize in this order:

Ignore low-impact warnings (like minor meta description length) until the big items are handled.

Step 5: Turn Findings Into a To-Do List

You now have raw data. Convert it into a short, actionable list. Example:

1. Fix 3 broken links found in Site Audit.
2. Rewrite title tags on 5 pages with duplicate titles.
3. Improve 4 pages ranking in positions 6–12 by adding missing subtopics and internal links.
4. Remove or update 2 thin pages with no traffic.

Keep the list to 5–10 items max for your first audit. Finishing a short list beats starting a long one.

Common Beginner Mistakes

• Chasing every red flag. Site Audit flags many minor issues. Fix what affects rankings and users first.
• Trusting estimates as exact numbers. Ahrefs data is modeled, not measured from your analytics.
• Auditing a huge site too early. Start small to learn the interface.
• Ignoring search intent. A page can be technically perfect but still fail if it doesn't match what searchers want.
• Forgetting to re-crawl. After fixes, run Site Audit again to confirm improvements.

Where to Go Next

Once your first audit is done:

• Compare with competitors using Site Explorer's Competing Domains and Content Gap reports.
• Track keyword rankings over time with Rank Tracker.
• Explore backlink opportunities in the Backlinks and Link Intersect reports.
• Set up recurring Site Audit crawls so new issues surface automatically.

Your first audit isn't about perfection — it's about building a repeatable habit: enter a target, read the key reports, pick the highest-impact fixes, and act. Do that once a month and your site's health compounds.

Baseten supports two distinct first steps: calling a hosted model through Model APIs with an API key and the OpenAI SDK, or deploying your own model on dedicated GPUs using a config.yaml and the Baseten CLI. Choose the first if a supported model already fits your application and you want to start with an API call. Choose the second if you need a specific open-source model, a private checkpoint, or custom serving logic.

Path 1: Make your first inference call with Model APIs

Model APIs expose hosted endpoints for a curated set of models. Baseten manages the model, engine, hardware, and scaling, so you only supply an API key and a request.

What you need

• A Baseten account with an API key
• The OpenAI SDK installed in your environment
• A model from the supported Model APIs list

Steps

1. Get your API key from your Baseten workspace.
2. Install the OpenAI SDK if you have not already.
3. Send a request using the OpenAI client, pointing the base URL at Baseten's Model APIs endpoint and passing your API key.
4. Read the response the same way you would from any OpenAI-compatible Chat Completions call.

The expected result is a normal chat completion response. Because Model APIs support the OpenAI Chat Completions API (and the Anthropic Messages API in beta), you can reuse existing client code and swap the endpoint and key.

When this path fits

• A supported model meets your quality and latency needs.
• You do not want to manage containers, GPUs, or scaling.
• You want the fastest route from zero to a working call.

Path 2: Deploy your first model on dedicated infrastructure

Dedicated inference lets you deploy an open-source model, a private checkpoint, or a custom model on GPUs you control. Baseten still handles containers, GPU capacity across clouds and regions, scaling, and observability, but you define the model and its serving behavior.

Three ways to define a model

For a first deployment, the documented starting point is a Hugging Face model defined with config.yaml and deployed with the Baseten CLI. This avoids writing serving code while still giving you a dedicated deployment.

Steps for the config.yaml route

1. Pick a supported model architecture from Hugging Face.
2. Write a config.yaml that names the model, the hardware, and the inference engine.
3. Deploy with the Baseten CLI. The CLI builds the container, provisions GPU capacity, and routes traffic to your deployment.
4. Verify by sending a request to the deployment endpoint and checking the response.

The expected result is a running dedicated deployment you can call, with Baseten handling autoscaling, cold starts, and release promotion.

When to move to a Python class or Docker server

Switch from config.yaml when you need any of the following:

• Custom preprocessing or postprocessing of inputs and outputs
• Extra dependencies not covered by the default engine
• Custom server behavior that the config file cannot express

How to choose between the two paths

Start with Model APIs if a supported model works. Move to dedicated inference when model choice, customization, or environment control becomes a requirement.

Common sticking points

• Skipping the "Choose how to start" decision. The docs split into "Call a hosted model" and "Deploy your model" for a reason. Picking the wrong entry point wastes time.
• Reaching for a Docker server too early. If a supported architecture fits, config.yaml gets you deployed without serving code.
• Assuming Model APIs cover every model. They cover a curated set. Anything outside that set belongs on dedicated inference.
• Forgetting that pricing and limits are separate pages. Check the Pricing and limits and Billing and usage docs before committing to a path, since cost and quota behavior differ between hosted calls and dedicated deployments.

Use Model APIs when a supported hosted model already fits your application and you want to start with a single API call. Choose dedicated inference when you need to run an open-source model, a private checkpoint, or a custom model on GPUs you control. The deciding factors are how much customization you need and how much of the serving stack you want Baseten to manage for you.

The two paths at a glance

When Model APIs are the right fit

Model APIs expose hosted endpoints for a curated set of models. Because they support the OpenAI Chat Completions API (and the Anthropic Messages API in beta), you can point familiar client SDKs at them without writing serving code.

Pick this path when:

• A supported model already meets your application's needs.
• You want to start with an API call rather than a deployment.
• You don't want to think about model containers, GPU capacity, scaling, or observability — Baseten handles all of that.

The quickstart is exactly this: call a hosted model through Model APIs with an API key and the OpenAI SDK.

When dedicated inference is the right fit

Dedicated inference deploys an open-source model, a private checkpoint, or a custom model on dedicated infrastructure. You define the model in one of three ways, then deploy it with the Baseten CLI:

• config.yaml — for supported architectures, define the model, hardware, and inference engine without writing custom serving code.
• A Python model class — use this when you need custom preprocessing, postprocessing, dependencies, or server behavior.
• A custom Docker server — for full control over the serving environment.

Choose this path when you need control over the model itself, the hardware, autoscaling settings, and the release lifecycle — or when you need stable environments for development, staging, and production.

How to decide

Ask yourself these questions in order:

1. Does a supported hosted model already fit? If yes, start with Model APIs.
2. Do you need custom preprocessing, postprocessing, dependencies, or server behavior? If yes, you need dedicated inference — a Python model class or a custom Docker server.
3. Do you need to control hardware, autoscaling, or the release lifecycle? If yes, dedicated inference gives you that control.
4. Do you need separate development, staging, and production environments? Dedicated deployments support stable environments for each.

If you answered "no" to all of these, Model APIs will get you to a working call fastest.

What both paths share

Either way, you're running on production GPU infrastructure that Baseten manages across clouds and regions, including model containers, scaling, and observability. Inference engines optimize supported model architectures for production traffic. The difference is where the boundary of your responsibility sits: at the API call, or at the model definition.

For current pricing and usage details, see the Pricing and limits and Billing and usage pages.

Baseten is a platform for model inference and training that manages model containers, GPU capacity across clouds and regions, scaling, and observability on your behalf. If you want to know whether it is production-ready for running models, the short answer is: yes, for the parts it manages — you get dedicated infrastructure, autoscaling controls, cold-start handling, and a release lifecycle with stable environments for development, staging, and production. The trade-off is that the level of control you get depends on which deployment path you choose.

Two paths, two levels of control

Baseten offers two ways to run models, and they differ in how much of the operational stack you own.

With Model APIs, Baseten manages the model, engine, hardware, and scaling — you just call an endpoint. With dedicated inference, you define the model and Baseten handles the containers, GPU capacity, scaling, and observability around it.

How deployment works

For dedicated inference, you define the model in one of three ways, then deploy it with the Baseten CLI:

• A config.yaml — for supported architectures, this defines the model, hardware, and inference engine without any custom serving code.
• A Python model class — use this when you need custom preprocessing, postprocessing, or dependencies.
• A custom Docker server — use this when you need full control over server behavior.

The choice maps directly to how much custom logic you need. If a supported architecture fits, config.yaml is the lightest option. If you need to transform inputs or outputs, a Python model class covers it. If you need to change how the server itself behaves, go with a custom Docker server.

Once deployed, Baseten manages the model containers and the GPU capacity behind them, drawing on capacity across clouds and regions. Its inference engines optimize supported model architectures for production traffic, so you are not tuning serving performance from scratch.

How scaling and cold starts are handled

Dedicated deployments give you control over autoscaling settings. That means you decide how the deployment responds to traffic rather than accepting a fixed capacity. Baseten also handles cold-start behavior as part of the deployment lifecycle — relevant when a model scales down and needs to come back up under load.

The practical implication: you can tune for cost (scale down when idle) or for latency (keep capacity warm), and Baseten manages the mechanics of bringing instances up and routing traffic to them.

How release management works

Dedicated deployments support a release lifecycle with stable environments for development, staging, and production. This lets you promote a model version through environments rather than deploying straight to production. Combined with control over the model, hardware, autoscaling settings, and release lifecycle, this is what makes the dedicated path suitable for teams that need a repeatable promotion process.

What to check before committing

• Confirm your model architecture is supported if you want the config.yaml route — otherwise you will need a Python model class or custom Docker server.
• Decide your scaling posture up front — autoscaling settings are yours to configure, so know whether you are optimizing for cost or latency.
• Review pricing and limits before sizing a production deployment. Baseten publishes a Pricing and limits page and a Billing and usage page; the documentation does not state that any tier is free, so treat cost as something to verify rather than assume.
• Start with the quickstart if you have not deployed yet: call a hosted model through Model APIs with an API key and the OpenAI SDK, then move to a dedicated deployment once you know your requirements.

If your goal is simply to call a supported model, Model APIs remove nearly all operational work. If your goal is to run your own model in production with control over hardware, scaling, and releases, dedicated inference is the path — and Baseten handles the containers, capacity, scaling, and observability underneath it.

Yes. Baseten is a platform for both model inference and training, and its documentation states that you can train models and serve the resulting checkpoints. Two paths are documented: fine-tuning with Loops, or running your own training code with Training Jobs. Training runs on production GPU infrastructure, and the checkpoints you produce can then be served through Baseten's inference paths.

The two documented training paths

Loops (fine-tuning)

Use Loops when you want to fine-tune rather than write a training loop from scratch. The overview lists it as the fine-tuning option alongside Training Jobs. The documentation does not, in the material available here, spell out Loops' supported base models, dataset formats, or hyperparameters — check the Loops section of the docs before committing to it.

Training Jobs (your own code)

Use Training Jobs when you want to run your own training code on Baseten's GPU infrastructure. This is the more flexible path: you bring the training script, and Baseten provides the compute. As with Loops, the specifics of job configuration and artifact output are not detailed in the overview excerpt, so treat the Training Jobs docs as the source of truth for setup.

How training results get served

The overview states plainly that you can "train models and serve the resulting checkpoints." The serving side works through the same inference options Baseten offers generally:

A trained checkpoint is a private artifact, so serving it points toward dedicated inference rather than Model APIs — Model APIs expose a curated set of hosted models, not arbitrary checkpoints. On the dedicated side, you define the model in one of three ways:

• config.yaml — for supported architectures, defines the model, hardware, and inference engine without custom serving code
• Python model class — when you need custom preprocessing, postprocessing, or dependencies
• Custom Docker server — when you need full control over server behavior

Deployment is done with the Baseten CLI. Dedicated deployments also give you stable environments for development, staging, and production, plus control over autoscaling settings and the release lifecycle.

What Baseten manages for you

Across both inference and training, Baseten handles model containers, GPU capacity across clouds and regions, scaling, and observability. Its inference engines optimize supported model architectures for production traffic. That means the training-to-serving handoff does not require you to stand up your own container or GPU fleet — but it also means supported architectures matter: config.yaml-based deployment depends on the architecture being supported, which is why custom serving code exists as a fallback.

Practical starting order

1. Decide whether you need fine-tuning (Loops) or full control over training code (Training Jobs).
2. Run the training job and produce a checkpoint.
3. Choose a serving definition — config.yaml if your architecture is supported, otherwise a Python model class or custom Docker server.
4. Deploy with the Baseten CLI and verify with an inference call.

For pricing and usage limits on training and inference, see the "Pricing and limits" and "Billing and usage" pages in the docs; the overview excerpt does not include rates or quotas.