ForHosting KIT · Developer Utilities

Build a Competitor Feature Comparison Matrix

Turn scattered competitor research into a consistent feature comparison that is ready for analysis, reporting, or product planning.

● BetaFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Provide the competitors, list the features, and add one true-or-false support flag for every competitor-feature combination. The result preserves your requested order, creates a structured matrix, and totals the supported features for each competitor. Strict validation catches missing, duplicate, or unknown entries before an incomplete comparison can quietly influence a roadmap or sales conversation.

Prepare a complete and neutral comparison

Start by defining the competitor names in the exact column order you want to keep. Names must be unique, because every later support flag is matched to one of those names. Next, create one row for each capability you want to compare. A useful feature label is specific enough that two researchers would interpret it in the same way. For example, “SAML single sign-on” is more dependable than “enterprise security,” which could include several unrelated controls. Each feature row needs one support entry for every competitor, and every entry must contain a Boolean supported value. Use true only when the product meets the definition you selected; use false when it does not. The builder deliberately does not invent an “unknown” state or infer support from marketing language. If your evidence is incomplete, resolve it before building the matrix or adopt an explicit research convention outside this tool. This discipline produces a balanced input where every company is evaluated against precisely the same checklist rather than a collection of favorable facts gathered with different standards.

Understand the matrix and totals

The output returns the normalized competitor order, a matrix row for every feature, a supported-feature count for every competitor, and the total number of compared features. Within each matrix row, support is keyed by competitor name, making it straightforward for software to find a specific intersection without relying on an array position. The supported-feature totals count true flags only. They are useful as a quick completeness summary, but they are not automatically a ranking: a basic feature and a strategically decisive feature each contribute one point. If weighting matters, treat this result as the clean factual layer and apply documented weights in a separate analysis. The builder trims surrounding whitespace from names, rejects duplicate competitor and feature names, and requires complete coverage. It also rejects unknown competitors, duplicate flags, and values that are not actual Booleans. Those checks prevent common spreadsheet defects such as a missing cell shifting later values, two rows referring to the same vendor with slightly different spacing, or the text “false” being mistaken for a truthy value by downstream code.

Use the result in repeatable workflows

A structured matrix is most valuable when it becomes a repeatable artifact instead of a one-time slide. Save the input beside source links and a research date in your own system, then rebuild whenever evidence changes. Product teams can compare successive outputs to see which gaps closed; sales enablement teams can feed the rows into battlecards; analysts can transform the keyed flags into tables, charts, or scoring models. Because the algorithm is deterministic and uses no network calls, identical input always yields identical output. It does not browse competitor sites, verify claims, decide whether two differently worded capabilities are equivalent, or judge product quality. Those remain research responsibilities. For automation, submit the same JSON shape through the API for $0.002 per request. For occasional work, run it in the browser. In both cases, validation fails early when the feature list is empty or the comparison is incomplete, so a malformed dataset does not masquerade as a valid zero score. Review the resulting matrix with subject-matter owners before publishing externally, especially when support depends on plan level, geography, integrations, or configuration.

What you can do with it

Product gap analysis

Convert researched capability flags into a consistent matrix before prioritizing roadmap gaps.

Sales battlecard preparation

Create structured competitor comparisons that can be transformed into current, evidence-backed battlecards.

Vendor shortlist review

Count checklist coverage across shortlisted products while retaining every feature-level result for scrutiny.

FAQ

What happens when the feature list is empty?

The request fails with an invalid input error because an empty list cannot produce a meaningful comparison.

Must every feature include every competitor?

Yes. Each feature requires exactly one Boolean support flag for every listed competitor.

Does the count rank competitors?

No. It counts true flags equally; it does not weight features or judge their importance.

Does this tool research competitor claims?

No. It structures and validates the support data you provide without browsing or verifying external sources.

What does an API request cost?

Each API request costs $0.002. The browser version can run locally for occasional comparisons.

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-feature-matrix-build

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-feature-matrix-build \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"competitors":["Acme","Bravo","Cobalt"],"features":[{"feature":"Single sign-on","support":[{"competitor":"Acme","supported":true},{"competitor":"Bravo","supported":false},{"competitor":"Cobalt","supported":true}]},{"feature":"Audit log","support":[{"competitor":"Acme","supported":true},{"competitor":"Bravo","supported":true},{"competitor":"Cobalt","supported":false}]}]}'

const res = await fetch("https://api.kit.forhosting.com/biz/competitor-feature-matrix-build", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "competitors": [
      "Acme",
      "Bravo",
      "Cobalt"
    ],
    "features": [
      {
        "feature": "Single sign-on",
        "support": [
          {
            "competitor": "Acme",
            "supported": true
          },
          {
            "competitor": "Bravo",
            "supported": false
          },
          {
            "competitor": "Cobalt",
            "supported": true
          }
        ]
      },
      {
        "feature": "Audit log",
        "support": [
          {
            "competitor": "Acme",
            "supported": true
          },
          {
            "competitor": "Bravo",
            "supported": true
          },
          {
            "competitor": "Cobalt",
            "supported": false
          }
        ]
      }
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/biz/competitor-feature-matrix-build",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "competitors": [
        "Acme",
        "Bravo",
        "Cobalt"
    ],
    "features": [
        {
            "feature": "Single sign-on",
            "support": [
                {
                    "competitor": "Acme",
                    "supported": true
                },
                {
                    "competitor": "Bravo",
                    "supported": false
                },
                {
                    "competitor": "Cobalt",
                    "supported": true
                }
            ]
        },
        {
            "feature": "Audit log",
            "support": [
                {
                    "competitor": "Acme",
                    "supported": true
                },
                {
                    "competitor": "Bravo",
                    "supported": true
                },
                {
                    "competitor": "Cobalt",
                    "supported": false
                }
            ]
        }
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/biz/competitor-feature-matrix-build", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"competitors":["Acme","Bravo","Cobalt"],"features":[{"feature":"Single sign-on","support":[{"competitor":"Acme","supported":true},{"competitor":"Bravo","supported":false},{"competitor":"Cobalt","supported":true}]},{"feature":"Audit log","support":[{"competitor":"Acme","supported":true},{"competitor":"Bravo","supported":true},{"competitor":"Cobalt","supported":false}]}]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"competitors":["Acme","Bravo","Cobalt"],"features":[{"feature":"Single sign-on","support":[{"competitor":"Acme","supported":true},{"competitor":"Bravo","supported":false},{"competitor":"Cobalt","supported":true}]},{"feature":"Audit log","support":[{"competitor":"Acme","supported":true},{"competitor":"Bravo","supported":true},{"competitor":"Cobalt","supported":false}]}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/biz/competitor-feature-matrix-build", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "competitors": [
    "Acme",
    "Bravo",
    "Cobalt"
  ],
  "features": [
    {
      "feature": "Single sign-on",
      "support": [
        {
          "competitor": "Acme",
          "supported": true
        },
        {
          "competitor": "Bravo",
          "supported": false
        },
        {
          "competitor": "Cobalt",
          "supported": true
        }
      ]
    },
    {
      "feature": "Audit log",
      "support": [
        {
          "competitor": "Acme",
          "supported": true
        },
        {
          "competitor": "Bravo",
          "supported": true
        },
        {
          "competitor": "Cobalt",
          "supported": false
        }
      ]
    }
  ]
}

Example response

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

Read the full KIT documentation →