Prompt Engine is prompt infrastructure for backend teams. Build, version, test and deploy your LLM prompts without redeploying your backend.

Prompt Engine is prompt infrastructure for backend teams. Cook a structured prompt with Role, Goal, Constraints and Output Format, or write your own. Version it, test it against a real model, activate it. Your backend calls one endpoint and gets the live version back, variables already filled in.

No pull request. No deploy. No restart.

Start freeRead the docs
  • No card required
  • 3 engines free
  • 50 credits
  • Full API access

The idea

One string literal, or one endpoint

The difference between a prompt you have to deploy and a prompt you can change. Same model call on both sides.

In your repo today

// Changing one adjective here means a branch,
// a review, CI, a build and a deploy.
const prompt = `
  You score inbound B2B leads.
  Score ${company} (${industry}, ${headcount} staff)
  from 0-100. Weight company size heavily.
  Return JSON with score and reason.
`;

const scored = await openai.chat.completions.create({
  model: OPENAI_MODEL,
  messages: [{ role: "user", content: prompt }],
});

With Prompt Engine

// Fetch whichever version is live right now.
const { data } = await fetch(
  "https://api.promptengine.co.in/v1/engines/7/active-prompt",
  {
    method: "POST",
    headers,
    body: JSON.stringify({
      variables: { company, industry, headcount },
    }),
  },
).then((r) => r.json());

const scored = await openai.chat.completions.create({
  model: OPENAI_MODEL,
  messages: data.messages,
});

Everything below the fetch stops changing. Edit the prompt in the dashboard, activate it, and the next call returns the new one. No pull request, no deploy, no restart.

Two things break prompts in production.

Neither is a model problem. Both are the reason teams end up with prompts nobody trusts and nobody wants to touch.

01

Your prompt works. Until it doesn't.

Prompts get written by hand, in a hurry, with no structure. A paragraph of instructions and some hope. Then the output comes back as prose when you asked for JSON, or JSON that won't parse, or simply a different shape than the run before. The model didn't change. The prompt was never specified tightly enough to hold.

  • Same prompt, a different output shape every run
  • JSON that fails the parser at 2am
  • Instructions the model quietly ignores
  • No idea which edit made it worse

The prompt

look at this lead and tell me if theyre worth chasing

Three runs

Run 1→ prose

Yeah, Acme looks promising. Decent size and they've been active lately.

Run 2→ json

{ "score": 72, "reason": "Strong intent signals" }

Run 3→ won't parse

{ score: 'high', notes: [ "active", }

Same prompt. Three shapes. One of them crashes you.

02

One word. A full release cycle.

The prompt is a string literal in your repo, so changing it means changing your application. Branch, pull request, review, CI, build, deploy. The entire apparatus, to swap one adjective. So people stop tuning prompts altogether, because tuning costs a deploy.

  • A copy tweak stuck behind code review
  • Rollback means a revert commit and another deploy
  • Nobody outside engineering can touch a prompt
  • Prompt history buried somewhere in git log

prompts.ts

1 line changed
- tone: "neutral"
+ tone: "friendly"

To ship it

Commit2m
PR review4h
CI8m
Deploy6m
To change one adjective~4h 16m

We solved this for you.

Both halves, in one place: a way to cook prompts that hold their shape, and a way to change what's live without shipping code.

How it works

From nothing to a live prompt in four steps

The whole loop, start to finish. Steps one through three happen in the dashboard; step four is the only one that touches your code.

  1. 1

    Create an engine

    One per use case. It gets an ID, and that's what your code will reference.

  2. 2

    Write or cook a prompt

    Author it yourself, or let Kitchen draft one from a description. Mark variables with double braces.

  3. 3

    Test, then activate

    Run it against a real model. When it's right, activate it. That version is now live.

  4. 4

    Call the endpoint

    Your backend POSTs to the engine and gets the active prompt back, variables filled in.

Version control

Every prompt keeps its lineage

Edit a draft and it changes in place. Edit something that has already been live and Prompt Engine forks it instead, so the version that shipped stays exactly as it was, forever readable.

  1. 1Baseline scoring

    First version. Plain text, written by hand.

  2. 1.1Add firmographic signals

    Edited while it was still a draft, so it changed in place.

  3. 1.1.1Weight intent over headcountLive

    Forked from a version that had been live. Serving traffic now.

  4. 1.2Stricter disqualification

    A second branch off 1.1. Never activated, and costing nothing.

  • Open any past version and read the exact text that was serving traffic
  • Forking is automatic for anything that has been live, so history is never overwritten
  • Rolling back is not a special action: it is activating the older version again

Other platforms store the prompt you wrote. This one writes it with you.

Describe the job and Kitchen returns a structured recipe with every section the model needs, in the order it needs them, each one still editable.

KitchenOpenAI

What should this prompt do?

analyze inbound B2B leads and score how likely they are to convert

Cook it for me

No structure to learn. Kitchen decides which sections the task needs and writes each one.

The recipe

RoleRequired

You are a senior B2B revenue analyst. You qualify inbound leads for a sales team and you are hard to impress.

GoalRequired

Score {{company}} from 0-100 on likelihood to convert, and recommend one next action.

Context / Inputs

Industry: {{industry}} Headcount: {{headcount}} Intent signals: {{intent_signals}}

ConstraintsRequired

Never invent firmographics. If a signal is missing, weight it neutral rather than guessing.

Output FormatRequired

{ "score": number, "reason": string, "next_action": string }

Stop Rules

Return only the JSON object. No preamble, no code fences, no trailing commentary.

✓ Output Format and Stop Rules are why it returns the same shape every run.

Change what's live. The API follows.

Activating a version swaps what every call returns. Nothing redeploys.

Lead Analyzerengine 7
1Lead qualification4
1Baseline scoringInactive
1.1Add firmographic signalsInactive
1.1.1Weight intent over headcountLive
1.2Stricter disqualificationDraft
POST/v1/engines/7/active-prompt
{ "variables": {
    "company": "Acme Corp",
    "industry": "SaaS",
    "headcount": "240",
    "intent_signals": "pricing_page,demo_request"
} }

Response

{
  "success": true,
  "data": {
    "version": "1.1.1",
    "mode": "text",
    "text": "Score Acme Corp (SaaS, 240 staff) from 0-100. Weight intent signals above headcount. Return JSON with score, reason and next_action.",
    "missing_variables": []
  },
  "error": null
}

✓ No pull request. No deploy. The next call returns the new version.

Integration

One endpoint. That's the whole integration.

Call it wherever you'd have hardcoded the prompt. You get the live version back with your variables already substituted. Then hand it to whichever model you already use.

curl -X POST \
  https://api.promptengine.co.in/v1/engines/7/active-prompt \
  -H "Authorization: Bearer pe_live_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "variables": {
      "company": "Acme Corp",
      "industry": "SaaS",
      "headcount": "240",
      "intent_signals": "pricing_page,demo_request"
    }
  }'

You get back

{
  "success": true,
  "data": {
    "version": "3.0",
    "mode": "text",
    "messages": [
      { "role": "system", "content": "You score inbound B2B leads." },
      {
        "role": "user",
        "content": "Score Acme Corp (SaaS, 240 staff) from 0-100. Weight intent signals above headcount. Return JSON with score, reason and next_action."
      }
    ],
    "text": "You score inbound B2B leads.\n\nScore Acme Corp (SaaS, 240 staff) from 0-100. Weight intent signals above headcount. Return JSON with score, reason and next_action.",
    "missing_variables": []
  },
  "error": null
}

Full reference, error cases and a live tester in the API docs.

Run cost

Two ways to run. One of them is free.

Testing a prompt against a real model is the only thing here that costs anything. You choose whose key it runs on.

Use our models

Metered on real tokens

Runs on our OpenAI and Gemini keys and draws from a credit balance you can check at any time. Metered on actual token usage, with no hidden multipliers and no surprise at month end.

  • Nothing to set up. It works the moment you sign up
  • Every plan includes credits; paid tiers top up monthly

Use your own key

Free, always

Paste your own OpenAI or Gemini key for a run and it costs no credits at all. We never store it: it is used for that one call and discarded, and it is never written to a database or a log.

  • Zero credits, on every plan including the free one
  • Request-transient: held for the length of one call, then gone

Free on every plan, forever

  • Writing and editing prompts by hand
  • Versioning, forking and full history
  • Activating, deactivating and rolling back
  • Every call to the API

Production concerns

The unglamorous parts, already handled

The things you'd otherwise build yourself before this was safe to put in production.

One engine per job

An engine is a namespace for a single use case: your classifier, your summariser, your replier. Each keeps its own versions, so changing one can never disturb another.

Test before you activate

Run any version against a real model from inside the console, with your variables filled in, and see the actual output before a single user does.

API keys with a grace window

Rotate a key and the old one keeps working for 72 hours, so a rotation never takes production down. Stored hashed, shown once.

Tenant isolation

Engines are scoped to their owner. Someone else's engine 404s exactly like one that doesn't exist, so IDs can't be probed.

Variables

Mark placeholders with {{double_braces}} and pass them at call time. Anything you leave out comes back in missing_variables.

Exactly one live version

Enforced by the database, not by convention. An engine can never end up serving two prompts, whatever order activations arrive in.

Works with your models

OpenAI and Gemini today. What the API returns is finished prompt text, so it goes to whichever model you already call.

Usage you can see

Metered on real token usage and drawn from a balance you can check any time. No hidden multipliers, no surprise at month end.

Pricing

Pricing that tracks what you actually run

Every plan ships the whole product: engines, versioning, forking, Kitchen and the API. Paid tiers raise the limits and top your credits up every month.

Founding price

Lock today's price against everything we ship next.

Subscribe before 30 September 2026 and every feature we add is included at the price you're paying now: evaluations, side-by-side compare runs, team seats, more providers. No new tier, no upgrade prompt. Your price holds for as long as your subscription stays active.

Developer

Freeforever

Enough to wire it into a real project and watch it work.

50 credits to start
  • 3 engines
  • 10 versions per engine
  • 2 Kitchen-generated prompts
  • Full API access, no feature gates
  • Complete version history and rollback
  • Bring your own key: never stored, and free to run
Start free
Most valuable

Startup

₹999/ month

For a product with prompts in front of real users.

650 credits every month
  • 20 engines
  • 50 versions per engine
  • Unlimited Kitchen prompts
  • 500 bonus credits when you upgrade
  • Full API access, no feature gates
  • Complete version history and rollback
  • Bring your own key: never stored, and free to run
  • Priority support over email
Choose Startup

Horizon

₹4,999/ month

For teams running many prompt-backed features at once.

2,000 credits every month
  • 100 engines
  • 250 versions per engine
  • Unlimited Kitchen prompts
  • 1,000 bonus credits when you upgrade
  • Full API access, no feature gates
  • Complete version history and rollback
  • Bring your own key: never stored, and free to run
  • Priority support over email
Choose Horizon

Credits cover AI work: Kitchen generation and test runs against our models. Writing prompts by hand, versioning, forking, activating and calling the API never cost credits, on any plan. You can also bring your own provider key: we never store it, it's used for that one call and discarded, and those runs are free.

Questions

The things people ask before signing up

No, and it's a fair question: promptengine.cc is an unrelated product that shares the name. They make a prompt generator for individuals: you describe what you want and it writes a prompt you copy into ChatGPT or Claude. Prompt Engine (promptengine.co.in) is infrastructure for engineering teams: your prompts live here as versioned objects, your backend fetches the live one over an API, and you change what's running without redeploying. Different job, different buyer, no connection between the two companies.

Start in five minutes

Your prompts deserve a deploy pipeline.

Create an engine, activate your first version and call it from your code. The free plan is enough to do all three today.

Start freeRead the docs
  • No card required
  • 3 engines
  • 50 credits
  • Full API access