From Postman to production in minutes with REST Express

The worst day of most Unity backend integrations

Every Unity developer who has wired up a backend knows the shape of this day. You spend the morning nailing endpoints in Postman — headers, auth, tokens, body shape, everything green. Then you switch to Unity, open a fresh C# file, and slowly transcribe that work into UnityWebRequest boilerplate. Typos creep in. URLs drift. The coroutine style you chose two hours ago doesn't match what the team now expects. By the afternoon, you're debugging a header case-sensitivity issue instead of shipping the feature.

We lived that day too many times. Eventually we asked the obvious question: if Postman already knows all of this, why are we retyping it?

What REST Express does

REST Express is a Unity Editor tool that turns a Postman v2.1 collection into:

1. an interactive request runner inside Unity, and
2. a code generator that produces typed C# clients.

Drag in your Postman JSON. The collection populates as a tree. Click a request, fill in path / query / body, hit Send. You see the response without leaving the Editor. When you're happy, hit Generate — the code generator writes one static method per Postman request, with strongly typed request / response models inferred from the sample payloads.

The output fits into any Unity project. We don't force a DI framework, a coroutine style, or a specific runtime. You pick async or coroutine at generation time, and the code slots in next to your existing services.

A side-by-side

Before REST Express, a "Create user" method looked like this:

public void CreateUser(string username, string email, string password) {
    StartCoroutine(CreateUserCoroutine(username, email, password));
}

IEnumerator CreateUserCoroutine(string username, string email, string password) {
    var form = new WWWForm();
    form.AddField("username", username);
    form.AddField("email", email);
    form.AddField("password", password);
    using var req = UnityWebRequest.Post("https://api.example.com/users", form);
    yield return req.SendWebRequest();
    if (req.result != UnityWebRequest.Result.Success) {
        Debug.LogError(req.error);
        yield break;
    }
    Debug.Log("ok");
}

After REST Express:

var response = await UsersApi.CreateAsync(new CreateUserRequest {
    username = "ahmed",
    email = "ahmed@example.com",
    password = secret,
});
if (response.IsSuccess) { ... } else { Debug.LogError(response.Error); }

The generated code handles multipart, bearer auth, retries, and logging. The surface we expose to the rest of the game is just UsersApi. No coroutine plumbing, no form-building, no manual JSON deserialization.

What surprised us

• Postman accuracy is underrated. Because the collection doubles as the team's QA artifact, the generated client is always in sync with the team's mental model of the API. When the backend changes, you re-export, re-generate, and typing errors fall out at compile time.
• In-Editor testing became our default. We expected the Script Generator to be the hero feature, but the Importer's interactive runner ended up being what the team uses every day. Something about "same tool as the game" beats context-switching to Postman.
• "One endpoint, one method" scales. We tried fancier shapes (clients per domain, interfaces for mocking). In practice, the flat list of static methods is the thing that doesn't break as the project grows.

How to get it

REST Express is available on the Unity Asset Store for $15. Source is on GitHub under the MIT license — fork it, read it, or ship modifications.

If you're stuck on an API integration today and Postman has the answer, REST Express will turn that answer into code in an afternoon. That's the whole pitch.