ForHosting KIT · Finance & money

Money supply from MV=PQ

Find the money stock consistent with the equation of exchange: with a velocity of 5, a price level of 2 and real output of 2500, nominal output is 5000 and the money supply is 1000. Every step is shown. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Velocity: 5
Price level: 2
Real output: 2,500

You get

Money supply: 1,000
Nominal output: 5,000
Mv: 5,000
Pq: 5,000

Monetary-policy exercises, central-bank problem sets, and intermediate macro homework often give velocity, a target or observed price level, and real GDP, then ask for the money supply consistent with that identity. Rearranging for M is a single division, M equals PQ divided by V, but a zero velocity, a mixed-up deflator, or a sign error still produces a wrong stock. This money supply from MV equals PQ calculator accepts strictly positive velocity, price level, and real output, returns the implied money stock with product checks MV and PQ, and walks through the substitution so classroom answers and automation stay aligned.

What MV = PQ means when you are solving only for money supply

Irving Fisher's equation of exchange says the money stock multiplied by the number of times money circulates against final goods equals the price level times real transactions or real output. In textbook notation money supply M times velocity V equals price level P times real quantity Q, so MV equals PQ. Velocity is a turnover rate: how many times each unit of money is spent on the measured basket per period.

Price level may be a GDP deflator, a CPI-style index, or an average price consistent with how Q is measured. Real output Q is real GDP or the real volume of goods and services in that basket. Monetary-policy exercises usually treat V as given from recent accounts or a problem-set assumption, take P as a target or an observed deflator, take Q as potential or current real output, and ask what money stock is consistent with that triple.

Rearrange the identity for the stock: M equals PQ divided by V. That step is accounting, not a causal claim that printing M always raises P. Classical quantity-theory stories add extra assumptions—stable velocity and output near full employment—so a change in M maps into P.

This calculator does not impose those behavioral stories. It only solves the identity for M given strictly positive V, P, and Q. If velocity is five, the price level is two, and real output is two thousand five hundred, then nominal output PQ is five thousand and the implied money supply is one thousand.

Use the same units on P and Q so that PQ is a nominal flow in currency units per period and M is a stock in the same currency. The tool does not convert M1 versus M2 or annualize quarterly GDP; you must feed a consistent measurement pair.

Inputs, results and what gets rejected

Optionally send decimals as an integer from zero through twelve (default six) to control half-up rounding on every numeric field. Every input and the computed money supply must be strictly greater than zero: zero or negative velocity, prices, or real output is rejected because division by zero is undefined and negative quantities sit outside the standard classroom domain of monetary aggregates.

Formula and rearrange strings restate M equals PQ divided by V; equation fills the identity with the rounded numbers; message and ordered steps show the given triple, the identity, the rearrange, and the numerical substitute you can place next to a homework or LMS answer. Example: velocity five, price level two, real output two thousand five hundred yields money supply one thousand because M equals two times two thousand five hundred divided by five.

What you can do with it

Monetary-policy classroom exercises

Give students velocity, a price-level target, and real output and let them check that the implied money supply equals PQ divided by V against the textbook identity.

LMS and exam auto-grading

Mark equation-of-exchange items that ask for M with a deterministic oracle that rejects zero velocity and non-positive P or Q instead of accepting hollow empty answers.

Macro notebooks and policy labs

Batch-back out the implied money stock from published velocity, a GDP deflator, and real GDP without spreadsheet formula drift.

FAQ

What is the formula for money supply in MV = PQ?

Rearrange the equation of exchange for the stock: M = PQ / V. Nominal output PQ divided by velocity is the money supply consistent with those three knowns.

Does this calculator use the growth-rate form of the quantity theory?

No. It solves the level identity MV = PQ for M only.

What is the velocity of money?

It is a turnover rate: how many times each unit of money is spent on final goods and services in a period. A velocity of 5 means each unit changes hands five times over that period.

Why must velocity be greater than zero?

Because the money supply is found by dividing nominal output by velocity, and dividing by zero is undefined. The price level and real output must also be greater than zero.

Does a bigger money supply always raise prices?

Not by this equation alone. MV = PQ is an accounting identity, not a claim about cause. The quantity theory adds assumptions, such as stable velocity and output near full employment, before more money means higher prices.

Related tools

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/econ/money-supply-mv-pq

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/econ/money-supply-mv-pq \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"velocity":5,"price_level":2,"real_output":2500}'

const res = await fetch("https://api.kit.forhosting.com/econ/money-supply-mv-pq", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "velocity": 5,
    "price_level": 2,
    "real_output": 2500
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/econ/money-supply-mv-pq",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "velocity": 5,
    "price_level": 2,
    "real_output": 2500
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/econ/money-supply-mv-pq", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"velocity":5,"price_level":2,"real_output":2500}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"velocity":5,"price_level":2,"real_output":2500}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/econ/money-supply-mv-pq", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "velocity": 5,
  "price_level": 2,
  "real_output": 2500
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "econ.money_supply_mv_pq",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Technical notes

The equation of exchange states that the money stock times how often money turns over equals the price level times real output: MV equals PQ.

Input contract, response fields, and validation rules

POST a JSON body with three required finite numbers: velocity (aliases v, money_velocity, V), price_level (aliases p, price, P), and real_output (aliases q, output, quantity, y, real_gdp, Y, Q). Missing a required field, empty strings that fail numeric parse, non-finite values, magnitudes above the allowed absolute limit, and decimals outside the allowed range fail with invalid_input and are not billed. On success the body returns money_supply as the primary result, echoes velocity, price_level, and real_output, and includes product checks mv and pq plus nominal_output equal to PQ so you can confirm that MV matches PQ after rounding. Pair the response with your own multi-period table if you need growth rates or percentage changes in M, V, P, or Q; this endpoint solves only the level form of MV equals PQ for the money stock.

Where a money-supply-from-MV-equals-PQ API earns its keep

Principles and intermediate macro courses use a money supply from MV equals PQ calculator so students can recover the stock that is consistent with a given velocity, price level, and real output without algebra slips when the unknown sits in the numerator of a rearranged product. Exam generators and LMS plugins need a deterministic oracle that rejects zero velocity and non-positive prices or quantities instead of inventing infinity or silently returning null that a buggy grader might treat as correct. Failed validation does not consume balance. Policy-lab notebooks and teaching dashboards often back out the implied money stock from a published velocity, a GDP deflator, and real GDP when they walk through an open-market or quantity-theory exercise; pinning that arithmetic in a tiny parse API keeps spreadsheet drift out of the comparison column. Keep requests small, pin the rounded money_supply and product fields in tests, and you get reproducible equation-of-exchange numbers for homework, LMS plugins, and edge workers without standing up a full national-accounts or DSGE pipeline of your own.

Technical questions

How do I find money supply from the equation of exchange MV = PQ?

Send strictly positive velocity, price_level, and real_output. The API returns money_supply = (price_level × real_output) / velocity together with product checks and substitution steps.