Power Platform Community Forum Thread Details

Hi everyone.

I have a simple Power Automate cloud flow that processes incoming emails. One of the steps uses the standard "Classify into custom categories" AI Builder action. The only input is the email body preview (plain text, typically a few sentences), and the output is a category label + a confidence score (0-100).

When I search online for the expected cost of this action, every source I find says it should consume 1-2 AI credits per prediction. However, when I look at the run details of a single execution, the action itself reports 20 credits. And when I check my actual billing/usage receipt, it shows 100 AI credits consumed for what should be a single classification call.

So I'm seeing three different numbers for the same operation:

Documentation / community sources → 1-2 credits
Run output details → 20 credits
Billing receipt → 100 credits

Has anyone experienced this discrepancy? A few specific questions:

Is there a known multiplier or hidden cost associated with "Classify into custom categories" that isn't reflected in the documentation?
Could the 100-credit charge be caused by the action internally making multiple API calls (e.g. retries, pre-processing, or chunking the input)?
Is there a way to see a detailed credit breakdown per action within a flow run?
Would I be better off switching to a different approach — for example using an HTTP action to call the AI Builder prediction API directly, or using a custom GPT/Azure OpenAI prompt via an HTTP connector — to get more transparency and control over costs?

Any insight would be appreciated. Happy to share screenshots of the run details and billing if that helps.

Thanks!

Categories:

AI Builder

Building flows

Hi,

This is a really good observation, and you’re not alone—this behavior can look confusing when you compare documentation, run history, and billing.

From what you’ve shared (and based on similar scenarios I’ve worked on), the difference usually comes from how AI Builder credits are calculated vs how they are displayed.

A few key points to clarify:

Expected consumption (documentation)
For AI Builder classification models, Microsoft documentation generally indicates that a single prediction typically consumes 1 AI Builder credit per prediction (sometimes up to ~2 depending on complexity).
Why run history may show higher (e.g., 20 credits)
The value you see inside the flow run (like 20 credits) is often aggregated or rounded consumption, not always a 1:1 reflection of a single API call. It may include:

Internal processing steps
Model overhead
Rounding to minimum billable units

Why billing shows even higher (e.g., 100 credits)
This is the most confusing part, but typically happens due to one of these reasons:

Multiple executions of the action
Even if the flow looks like a single run, loops, retries, or parallel branches can trigger the AI action multiple times
Minimum billing units / batching behavior
AI Builder sometimes applies minimum credit consumption blocks, so even small requests may be billed at a higher unit
Pre-processing / internal calls
Some AI Builder actions (including classification) may internally perform multiple operations (like preprocessing or scoring), which are not visible in the flow but contribute to total consumption

No detailed per-call breakdown (current limitation)
At the moment, Power Automate does not provide a granular per-call credit breakdown inside a flow run. You typically see:

Per action summary (in run history)
Aggregated consumption (in billing / capacity reports)

About switching to HTTP / custom models
Your thought is valid. Using:

HTTP + Azure OpenAI / external API
Or custom endpoints

can give you more transparency and control over usage. However:

AI Builder is more integrated and easier to maintain
External APIs give better cost visibility but require additional setup and governance

From your screenshots, one important thing to check is:

Whether the flow is triggering multiple times
Or if the AI action is inside any loop / retry scenario

Even a small loop can multiply credit usage quickly.

In summary:

Documentation (1–2 credits) reflects ideal per prediction cost
Run history shows aggregated action consumption
Billing may include multiple executions + minimum billing units + internal processing

Hope this helps clarify the discrepancy.
If you need any more help on this, feel free to @mention me and I’ll try to assist further.

If this helps resolve your question, please consider marking the response as Verified so it can help others facing a similar scenario.
If you found this helpful, you can also click “Yes” on “Was this reply helpful?” or give it a Like.