Avatrix Now Has an API: Create AI Influencers and UGC Videos

Avatrix now has a public API. You can generate AI influencers, images, UGC videos, creative videos and voice straight from code, or by plugging it into n8n, Make or Claude, without even opening the site. The base URL is https://avatrix.io/api/v1, authentication uses a token you generate in your account, and under the hood runs the same engine that more than 5,000 creators already use inside the platform. This post is the map: the first request in three lines, the endpoints, what it costs in credits and who it's for.

What can you do with the Avatrix API?

You can run almost everything the platform does from code: generate images, create an AI influencer, animate her into a UGC video, make creative videos, generate voice, and also edit images, swap characters and enhance skin. The API exposes the same engine as the app: image models such as Reference and Creative, and video models such as AI Video 1 and AI Video 7. The only thing that changes is that you trigger the generation from your own server, not from the screen.

The difference isn't quality, it's control. In the app you create one at a time, by hand. Through the API you run batches, on whatever schedule you want, inside your own workflow. That's what separates "creating content" from "having a content pipeline that runs on its own."

The user base already exists, and it's big. There are 5,674 creators on the platform and more than 5,000 pieces of content generated since launch, with 82% of generations completing successfully (Avatrix's own data, database snapshot from June 2026). The API isn't a new product launched in the dark: it's the same machine real people already run, now open by request.

How do I make my first request? (3-line quickstart)

You make your first request in three steps: generate a token in your account, send a POST to /generate/image with that token, and check the result by its taskId. There's no required SDK and nothing to install: it's plain HTTP, and it works with curl, with the language you already use or with an HTTP node in n8n.

Step 1: generate the token. The access token (or PAT) is the key that identifies your account on every API call. In your account, go to avatrix.io/account/tokens and create one, choosing its scopes (for example generate:image). It starts with av_ and is shown only once: copy it and keep it somewhere safe. It goes in the header of every request.

Step 2: send the generation. A POST to /generate/image with the token, the model and the prompt. To pick the model, list the available ones with GET /api/v1/catalog/models (scope read:catalog) and put one of the returned id values in place of <MODEL_ID>:

curl -X POST https://avatrix.io/api/v1/generate/image \
  -H "Authorization: Bearer av_YOUR_TOKEN_HERE" \
  -H "Content-Type: application/json" \
  -d '{"model": "<MODEL_ID>", "prompt": "an influencer in a coffee shop, natural window light"}'

The response comes back right away, but it isn't the image: it's the task's ticket number:

{ "success": true, "data": { "taskId": "<task-id>", "status": "queued" } }

Step 3: get the result. With the taskId, check the task until it's ready:

curl https://avatrix.io/api/v1/tasks/YOUR_TASK_ID \
  -H "Authorization: Bearer av_YOUR_TOKEN_HERE"

When the status turns completed, the response includes the resultUrl with the generated file. That's the cycle for every generation, and the next section explains why it works this way.

How does generation work: taskId, polling and webhook?

Every generation in the Avatrix API is asynchronous. You send the request and immediately get a 202 with a taskId and status: queued, not the image or the video. That makes sense: generating video takes time, and holding the connection open while you wait would be fragile. Instead, the API hands you a ticket number and keeps working.

From there, you have two paths. The first is polling: you call GET /tasks/:id every so often, and the status moves from pending to submitted, processing and finally completed (or failed). When it completes, you get the resultUrl; when it fails, you get the error message. It's simple to implement and good for getting started.

The second is the webhook, which is cleaner at volume. You pass a callbackUrl when you create the generation. When the task finishes, Avatrix sends a POST to your address with the result link and the credits spent. That way you don't keep asking "is it ready yet?": the result comes to you. The most robust setup is to use the webhook and keep polling as a safety net.

What are the API endpoints?

The endpoints fall into three generation families (image, video and audio), plus the read routes (balance, status, profile). Each token carries scopes, and the scope unlocks a group of endpoints. If you only need images, create a token with generate:image and you're set. This is the part that matters most:

There are more read routes (profile, subscriptions, orders), and the full list, with the body of each request, lives in the official docs at avatrix.io/api/docs: that's the living source, always ahead of any blog post. Two public routes need no token: GET /health, to check whether the API is up, and GET /plans, which returns the plans and packs.

How much does each generation cost in credits?

You pay in credits, the same way you pay in the app: the API doesn't charge anything on top. By running the API itself in June 2026, we measured the real cost of each generation by watching the credits leave the balance:

Video varies because it depends on the model and the duration: video-creative accepts different models (from more economical ones to heavier ones), and the cost changes with that. Images stay at a steady 10 credits. Voice is the cheapest, at 1 credit per generation.

Credits come in two ways: inside the monthly plans (Creator, Pro and Ultimate), billed in US dollars by card, or in one-time credit packs paid by card, with no subscription, that don't expire: you buy them, use them whenever you want and the balance stays there. For automation, that matters: you can top up for a batch, run the pipeline and only top up again when you need to, with no subscription dictating the pace. If you buy credits through the API itself (POST /credits), the payment method there today is Pix, Brazil's instant payment system; card purchases happen on the site.

Who is this API for? Three kinds of use

The API serves three very different profiles, and the way you use it changes with each one. Knowing which one fits you already tells you whether you'll write code, build a flow or just talk to an agent.

The integrating developer. Someone building a product, an app or a dashboard who wants AI image and video generation inside it, without sending users off to another tool. They call the endpoints directly, handle the taskId and listen for the webhook. For this profile, the API is Lego: a generation block that snaps into what they already have.

The no-code creator. Someone who doesn't code but wants scale. This is where n8n, Make and Zapier come in: you build a flow that, for example, reads a spreadsheet of prompts, triggers an Avatrix generation for each row and saves the result to a folder. It's a content pipeline without writing code, just dragging blocks.

The AI agent operator. Someone who uses an assistant like Claude to orchestrate tasks. With the API connected, instead of opening the site and clicking, you ask in plain language ("make three variations of this influencer on a beach") and the agent fires off the generations for you. It's the format going viral right now in "I made AI content at scale with Claude" tutorials, and Avatrix fits right into it.

Can you use it in n8n, Make or Claude?

Yes. Since the API is REST with token authentication, any tool that can make an HTTP call can generate through Avatrix, and n8n, Make and Zapier all can. You use the generic HTTP node, paste the URL https://avatrix.io/api/v1/generate/image, add the header Authorization: Bearer av_YOUR_TOKEN and the JSON body. The flow handles the rest: it triggers the generation, waits and grabs the resultUrl.

To hook it into an AI agent like Claude, the path underneath is the same, with one extra layer. The Model Context Protocol (MCP), the open standard Anthropic launched in November 2024 (Anthropic, 2024), is what lets an assistant use external tools inside the conversation. With Avatrix behind it, "generate an influencer" stops being a click on the site and becomes a text request the agent carries out.

That layer already exists: Avatrix has an MCP connector for Claude and ChatGPT, so you can ask for generations right in the chat. It runs on the same foundation as the API: token, endpoint and a response with a link. Everything the agent needs to work is already live.

What doesn't the API do yet?

It's worth being upfront about the limits, because they save you headaches later. The API is solid at what it delivers, but it has clear boundaries.

First, it's server to server. The av_... token wasn't made to run in the browser (there's no open CORS), because putting a generation token in the front end would expose your credits to anyone. The token belongs in your back end, in n8n or in the agent, never in code the end user can see.

Second, there's a rate limit: 60 requests per minute and 20 generations running at the same time per account. Go past that and the API answers 429, and you wait. For a big batch, that means queuing at a steady pace, not firing everything at once. You also can't cancel a task once it's been sent: it runs until it finishes.

Third, some things are deliberately not exposed. There's no endpoint for swapping a real person's face: that's a conscious choice. For any question about what exists today, the docs at avatrix.io/api/docs are what counts.

API or the app: when should you use each?

Use the app when the work is hands-on: creating an influencer carefully, testing prompts, picking the best photo by hand. Use the API when the work is repetition: generating dozens of variations, feeding an app, running a pipeline that works while you sleep. It's not either-or: the same credits work in both.

The dividing line is volume. One influencer, a one-off campaign, a test: the app gets it done faster, with nothing to set up. Content at scale, integration into a product, real automation: that's where the API pays back the setup effort, because it takes you out of the middle of the process. The engine is the same; the only thing that changes is who presses the button, your hand or your code.

Frequently asked questions

How do I generate an Avatrix API token?

In your account, at avatrix.io/account/tokens, you create a token by choosing its scopes (what it's allowed to do) and an optional expiration date. It starts with av_ and is shown only once: the system only stores a hashed version of it. If you lose it, you revoke it and create another. The token goes in the Authorization: Bearer header of every request.

Is generation instant?

No, it's asynchronous. The request immediately returns a taskId with status: queued, and the generation runs in the background. You track it with GET /tasks/:id until it's completed and grab the resultUrl, or you get a webhook when it finishes. Images are ready in seconds; video takes longer, since it's heavier.

How is the Avatrix API different from other AI video APIs?

Focus. Most AI video APIs are built around corporate avatars or generic UGC. Avatrix is built around AI influencers that keep the same face in every photo and video. One account gives you more than 15 tools and several image and video models inside, the same credits work in the app and in the API, extra credit packs don't expire, and the interface is available in English and Spanish.

Can I resell generation or open it to my own users?

The API was designed for use in your own operation: your own pipeline, your own product, your own automation. Each token has scopes and a usage log, which helps you control what runs. Before building a product that passes generation on to third parties, check the usage rules in the official docs and talk to support: that's the right way to avoid surprises.

Do I need a paid plan to use the API?

Yes. Every generation spends credits and Avatrix has no free plan or free trial, so you need a balance, from either a monthly plan or a one-time credit pack paid by card. The good news is that the token costs nothing extra: the API uses the same credits you'd use in the app.

Start generating through the API

The Avatrix REST API is live and runs the same engine that more than 5,000 creators already use. You create your account, generate a token in seconds and fire off your first image with a curl. After that, it's about building the pipeline that makes sense for your workflow, in code, in n8n or in the agent.

The full docs, with every endpoint and every field, are at avatrix.io/api/docs. To run it now:

Create an account and get my API token →