Making API Calls in .NET the Easy Way with Refit

Introduction

Let’s be real — working with HttpClient in .NET can feel like assembling IKEA furniture without instructions. You can start confident, but soon you’re drowning in HttpRequestMessage, headers, serialization, and … what even is a StreamContent?
Enter Refit, the superhero we didn’t know we needed. It turns messy API calls into sleek, readable code, letting us focus on actually building stuff instead of fighting with HttpClient.
In this post, we’ll explore how Refit makes API calls ridiculously easy, step-by-step!

What is Refit? (And Why Should You Care?)

Refit is like a magical API builder for .NET. Instead of writing tedious HttpClient code, you simply define an interface, and Refit takes care of the rest.
Why Use Refit?
✔ Less Boilerplate Code - No more HttpClient clutter!
✔ Super Readable Code - API Callas looks like simple method calls.
✔ Automatic JSON Handling - No manual serialization/deserialization
✔ Easy Dependency Injection - Works smoothly in ASP.NET Core.
✔ Less Time Debugging, More time Watching Netfilx - Priorities, right?

Getting Started with Refit

Step 1: Install Refit
First, let’s bring Refit into our project. Run this in your terminal:

dotnet add package Refit.HttpClientFactory

Or use NuGet Package Manger:

Install-Package Refit.HttpClientFactory

Step 2: Define Your API Interface
Imagine we want to fetch GitHub repositories for a user. Normally, we’d be writing HttpClient spaghetti code. But with Refit, we just describe what we need:

using Refit;
using System.Collections.Generic;
using System.Threading.Tasks;

public interface IGitHubApi
{
  [Get("/users/{username}/repos")]
  Task<List<Repository>> GetUserRepositoriesAsync(string username);
}

public class Repository
{
  public string Name {get; set;}
  public string Description {get; set;}
}

What’s happening here?

• [Get(“/users/{username}/repos”)] - This tells Refit to make a GET request to GitHub.
• Task> - Refit automatically deserializes the response into a list of Repository objects.
• No HttpClient mess!

Step 3: Call the API (Like a Boss)
Now, let’s use our fancy new API client:

using System;
using System.Threading.Tasks;

class Program
{
  static async Task Main()
  {
    var gitHubApi = RestService.For<IGitHubApi>("https://api.github.com");
    var repositories = await gitHubApi.GetUserRepositoriesAsync("username");

    foreach (var repo in repositories)
    {
      Console.WriteLine($"Repo: {repo.name} - {repo.Description}");
    }
  }
}

Just like that, we’re fetching GitHub repositories with two lines of code. Clean, right?

Step 4: Using Refit in ASP.NET Core
If you’re working in an ASP.NET Core app, Refit fits right in with Dependency Injection.
In Program.cs, add:

using Refit;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRefitClient<IGitHubApi>()
  .ConfigureHttpClient(c => c.BaseAddress = new Uri("https://api.github.com"));

var app = builder.Build();
app.Run();

Now, in your services:

public class GitHubService
{
  private readonly IGitHubApi _githubApi;

  public GitHubService(IGitHubApi gitHubApi)
  {
    _gitHubApi = gitHubApi;
  }

  public async Task<List<Repository>> GetRepositories(string username)
  {
    return await _gitHubApi.GetUserRepositoriesAsync(username);
  }
}

Boom! No more clutter, just clean, maintainable code.

Conclusion
Refit removes the pain of API calls, letting you focus on building cool stuff instead of writing boilerplate code.

In the next post, we’ll go deepeer - authentication, error handling, and making your API calls even smarter.
Got questions? Drop them below