ForHosting KIT · Finance & money

Competitor price positioning calculator

If 2 of 4 competitors charge less than you and 1 charges the same, your price sits at the 75th percentile, shown next to the competitors' average price. You see at a glance whether you are cheap or expensive in your sample. 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

Price: 120
Competitor prices: 90, 100, 120, 150

You get

Competitor count: 4
Average competitor price: 115
Percentile position: 75
Competitors below: 2

The competitor price positioning calculator shows where your price sits in a market sample without requiring a spreadsheet or manual ranking. Enter your price and a non-empty list of competitor prices to receive two direct benchmarks: your percentile position and the average competitor price. The percentile reports the percentage of listed competitors priced at or below you, while the average summarizes the comparison set alone.

Read the percentile as a market position

The percentile position answers a focused question: what percentage of the competitors in this sample charge no more than you do? The calculator counts every competitor price below your price and every exact match, divides that count by the total number of competitor prices, and multiplies by 100. A result of 75 means that 75 percent of the submitted competitors are priced at or below your level, while the remaining 25 percent are priced above it.

A low percentile therefore indicates a comparatively inexpensive position, and a high percentile indicates a comparatively expensive position. Exact matches count as positions your price has reached, so several identical market prices can move the percentage together. This definition is intentionally explicit because percentile-rank conventions can treat ties differently.

Use the returned below, equal, and above counts to audit the result and explain it to colleagues. Remember that the result describes only the competitors you supplied; it is not automatically representative of the entire market.

Build a useful competitor price sample

Good positioning starts with comparable observations. Include offers that solve the same customer problem, target a similar buyer, and contain roughly equivalent quantities, contract periods, service levels, or features. Convert currencies and billing periods before submitting the list, because the calculator treats every number as directly comparable and does not infer units.

Do not include your own price among the competitor prices: your price is supplied separately, and adding it to the list would affect both the average and the percentile denominator. Preserve legitimate duplicate prices when different competitors independently charge the same amount, since each offer is a real market observation. Remove stale listings, unavailable promotional prices, and mismatched package tiers unless they belong to the decision you are studying.

For recurring analysis, keep a dated source table outside this calculator and submit the same defined peer group each time. A consistent sample makes changes in the output more meaningful and prevents competitor selection from quietly determining the conclusion.

Use the average and percentile together

The two outputs describe different aspects of the same comparison. The average competitor price gives a monetary reference point, while percentile position describes how many observations fall on either side of your price. An unusually high or low competitor price can pull the average substantially without changing the ordering of most offers, so neither measure should be interpreted alone.

For example, your price can sit above most competitors yet remain below the average when one premium outlier raises that average. Review the returned competitor counts to see the distribution around your price, then compare the average with the actual commercial context: features, quality, delivery, support, and contract terms. The tool does not recommend a new price or estimate demand, margin, revenue, or willingness to pay.

Instead, it creates a reproducible descriptive benchmark that can feed a pricing review. Run scenarios with proposed prices against the same competitor set to see how position changes, and document why any later pricing decision is commercially justified rather than treating a percentile as a target by itself.

What you can do with it

Review a proposed product price

Place a planned price within a defined competitor set before approving a launch or catalog update.

Monitor market repositioning

Repeat the calculation with a consistent peer group to see whether your relative position changes after market price updates.

Compare pricing scenarios

Test several candidate prices against the same competitor list and quantify how each scenario changes the percentile position.

FAQ

How is percentile position calculated?

It is 100 times the number of competitor prices at or below your price divided by the total competitor count.

How are prices equal to mine treated?

Exact matches count as being at or below your price. The response also reports equal prices separately so the tie effect is visible.

What does a percentile position of 75 mean?

It means 75% of the competitors you listed charge the same as you or less, and the remaining 25% charge more. A low percentile signals a comparatively inexpensive position; a high one, an expensive position.

Should I include my own price in the competitor list?

No. Your price is entered separately; adding it to the list would change both the average price and the number of competitors the percentile is based on.

Which competitor prices should I include?

Comparable offers: ones that solve the same customer problem, for a similar buyer, with equivalent quantities, contract periods or service levels. Convert currencies and billing periods first, and keep identical prices from different competitors.

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/biz/competitor-price-position

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/biz/competitor-price-position \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"price":120,"competitor_prices":[90,100,120,150]}'

const res = await fetch("https://api.kit.forhosting.com/biz/competitor-price-position", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "price": 120,
    "competitor_prices": [
      90,
      100,
      120,
      150
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/biz/competitor-price-position",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "price": 120,
    "competitor_prices": [
        90,
        100,
        120,
        150
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/biz/competitor-price-position", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"price":120,"competitor_prices":[90,100,120,150]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"price":120,"competitor_prices":[90,100,120,150]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/biz/competitor-price-position", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "price": 120,
  "competitor_prices": [
    90,
    100,
    120,
    150
  ]
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "biz.competitor_price_position",
  "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.

Limits

`max_competitors`	10000
`max_abs_price`	1000000000000000

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 calculation is deterministic, transparent, and suitable for repeatable pricing reviews through the browser or API.

Technical questions

Does the average include my price?

No. The average uses only the values in competitor_prices; your price is kept separate.

What happens if the competitor list is empty?

The request returns an invalid_input error because a competitor average and relative percentile cannot be computed without competitors.

What does the API request cost?

Each API request costs $0.002. The calculation is also available through the browser experience for this tier.

Read the full KIT documentation →

Run — free