P34 is a pre-trained economic decision model behind one REST API. Post the options in front of you — hundreds to thousands of candidate deals — with the history of what happened before. It returns a quantity for every option, zero meaning pass, and the predicted profit of the plan as a whole.
# 1 · validate: free, no key
curl -s -X POST https://api.hyperc.com/v1/validate \
-H "Content-Type: application/json" --data @request.json
# 2 · fit: returns a session id in seconds
curl -s -X POST https://api.hyperc.com/v1/fit \
-H "Authorization: Bearer $P34_API_KEY" \
-H "Content-Type: application/json" --data @request.json
# 3 · poll: minutes later, the plan
curl -s https://api.hyperc.com/v1/result/$SESSION_ID \
-H "Authorization: Bearer $P34_API_KEY"import os, time, requests
API = "https://api.hyperc.com/v1"
H = {"Authorization": f"Bearer {os.environ['P34_API_KEY']}"}
requests.post(f"{API}/validate", json=req) # 1 · free, no key
sid = requests.post(f"{API}/fit", headers=H, json=req).json()["session_id"]
while (res := requests.get(f"{API}/result/{sid}", headers=H).json())["status"] \
not in ("done", "failed"): # 3 · minutes later
time.sleep(30)
plan = [r for r in res["menu"] if r["qty"] > 0] # 0 = passconst API = "https://api.hyperc.com/v1";
const H = { Authorization: `Bearer ${process.env.P34_API_KEY}`,
"Content-Type": "application/json" };
const post = (p, b, h = H) => fetch(API + p, { method: "POST", headers: h,
body: JSON.stringify(b) }).then((r) => r.json());
await post("/validate", req, { "Content-Type": "application/json" }); // 1 · free
const { session_id } = await post("/fit", req); // 2
let res; // 3 · poll
do { await new Promise((r) => setTimeout(r, 30_000));
res = await fetch(`${API}/result/${session_id}`, { headers: H }).then((r) => r.json());
} while (!["done", "failed"].includes(res.status));{"status": "done", "model": "rc012.2", "n_selected": 10,
"predicted_profit_sum": 59.82,
"menu": [{"key": "h10-1519-1055", "qty": 2.0, "profit": 9.19},
{"key": "h10-1519-1056", "qty": 2.0, "profit": 4.26}, …]}Most models score rows one at a time. P34 answers the question a buyer actually faces: given everything on offer right now, which options to take, how many, and what profit to expect from the set. It is trained against realized economic outcomes, not text, and it calibrates to your market from your own history before it answers.
You do not train a model. Each fit calibrates P34 to your market from the history you send, then decides today's menu.
A fit is an asynchronous job that takes minutes. P34 is built for purchasing-style decisions, not high-frequency trading.
P34 places no orders. It returns a plan; your application, or a person, decides what to buy.
Session 9e6c8df2. The simulator's outcome for the same quantities was $66.98. Recorded run, not generated now: a simulator outcome is a counterfactual for the quantities shown, not an executed trade, a customer result or evidence of live-market profitability. Download the full result (JSON).
POST /validate checks a request's structure, columns, menu rules and volume floors. It needs no key, queues nothing and charges nothing.
Run it on our sample request — 300 generated offers from a made-up reseller — then on your own data. When it passes, an input test ("mock": true) runs every check a real fit runs, still free.
# the sample request: 300 generated offers from a made-up reseller
curl -sO https://hyperc.com/lp/sample/p34-sample-request-v1.json
# validate it: free, no key, nothing queued or charged
curl -s -X POST https://api.hyperc.com/v1/validate \
-H "Content-Type: application/json" \
--data @p34-sample-request-v1.jsonimport requests
API = "https://api.hyperc.com/v1"
req = requests.get("https://hyperc.com/lp/sample/p34-sample-request-v1.json").json()
# validate: free, no key, nothing queued or charged
v = requests.post(f"{API}/validate", json=req).json()
print(v["ok"], v["errors"], v["counts"])// Node 18+, saved as validate.mjs
const API = "https://api.hyperc.com/v1";
const req = await (await fetch("https://hyperc.com/lp/sample/p34-sample-request-v1.json")).json();
// validate: free, no key, nothing queued or charged
const v = await (await fetch(`${API}/validate`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(req),
})).json();
console.log(v.ok, v.errors, v.counts);{
"ok": true,
"errors": [],
"counts": {
"menus_rows": 1800, "menus_keys": 300, "t0_rows": 900,
"history_rows": 900, "menus": 13, "sales_rows": 450
},
"estimate": {
"pricing_mode": "runtime",
"note": "an estimate from row counts alone; …"
},
"checked": "structure, columns, menu-0/T=0 rules, volume floors. …"
}POST /fit answers in seconds with a session_id. Poll GET /result/{id}; cancel with DELETE /session/{id}.
Validation needs no key. Input tests return placeholders in the real result shape, clearly marked, on every key.
Describe fees, holding costs and write-offs in a paragraph. P34 compiles it into the code that values your history — and reuses it while the description and schema stay the same.
Pin model for reproducible results or follow default. The version that ran is echoed back.
confidence_correction trades fewer, surer picks against more. The sweep in every result shows the trade-off without another fit.
Up to 100,000 menu rows per request, as JSON records or base64 Parquet.
Every fit reports what it charged. GET /account/ledger lists every movement. Failures on our side are not charged.
Four open agent skills, llms.txt and a paste-in instruction for Claude Code, Codex or your IDE agent.
P34 earns its cost where every decision faces hundreds to thousands of candidate deals and most of them should be turned down. If a menu holds a handful of options, the market, the collection or the plan is wrong.
This week's supplier offers, each at several order sizes: what to buy, and how many.
Listings across marketplaces, priced against what similar items sold for: which to flip.
The fastest loop to prove: trades resolve in days, so history and results arrive quickly.
Thousands of names expire every day: which to back-order, with what you know about resale.
Loads on the board, lane by lane: which to accept with the trucks you have.
Pallets, equipment and returns lots: which to pursue, against your resale history.
Not a fit: decisions needed in under a second; a handful of options you could score by hand; trading regulated securities, derivatives or prediction markets, which sit outside the self-serve terms. Browse the computable-markets catalogue for more.
POST /validate — no key, no account"mock": true| What | When | Cost |
|---|---|---|
| Validate a request | POST /validate, no key or account | Free |
| Input test | "mock": true — every input check, placeholder result | Free |
| Grounding | your business description or data schema is new | typically 17–20 tokens |
| Grounding, repeated | identical description and schema: the compiled code is reused | replay metered as compute |
| Model fit | compute time: 0.25 tokens per CPU core-hour, 5–10 per GPU-hour, at least 0.25 per calculation | typically 3–10 tokens |
| A failure on our side | grounding or the fit fails for a reason that is ours | Not charged |
1 token = US$1. Typical figures are from recent fits (early October 2026); yours follow the size of your history and menus. Every charge is itemized: /fit reports what it charged and each ledger entry spells out its arithmetic. A grounding stopped by a problem in your input is charged for the work done, and its diagnosis says what to change. Prices exclude taxes; tokens are not refundable. Want an always-on workspace for your agent, with data tools and weekly plan credits? That is the membership, a separate offer.
Register free in the console and choose the pay-as-you-go API. Your key is ready the moment the account exists; keep it in an environment variable, never in code.
Get API key →Shape your data, run POST /validate until it passes, then an input test with "mock": true.
Buy tokens from $15, submit an actual fit, poll the result and review the plan before anything is bought.
Your first purchase plan →No. Register free, buy tokens from US$15 and spend them on fits; nothing renews. The membership ($200 a month) is a separate offer that adds a managed agent workspace, data tools and weekly plan credits.
Typically 20–30 tokens (US$20–30) for the first fit on new data: grounding your economics (17–20) plus compute (3–10). Repeat fits with the same description and schema reuse the compiled economics. Cost follows the size of your history and menus; the pricing page has the rates.
Those pick one answer from a list you define, in milliseconds, one item at a time. P34 decides a whole menu at once: it calibrates to your history and your costs, then returns a size for every option and the predicted profit of the plan. That takes minutes, and it is built for buying decisions where most options should be refused.
Yes. POST /validate needs no key and no account, and input tests with "mock": true are free on every key. Only actual fits spend tokens.
Calls that need tokens are refused with HTTP 429, and nothing is queued or charged for a refused call. Validation and input tests keep working. Buy tokens in the console and resubmit.
No. Tokens you buy stay on your balance and never expire. They are not refundable.
A fit takes minutes: it grounds your history, calibrates the model and decides the whole menu. It is built for purchasing-style decisions, not sub-second ones.
Menus of candidate deals — hundreds at least on the current one — with past menus that include the options nobody took, a sales log of what happened, and a paragraph on your unit economics. No trading record? A history assembled from market research is accepted. See Prepare your data.
It is plain HTTPS and JSON, so any HTTP client works. We publish a standard-library Python quickstart, a sample client and a pytest workflow in P34-API-DOCS, plus four agent skills.
Revoke it in the console (API keys → revoke) and create a new one; a revoked key stops working at once. Keep keys in environment variables, one per application or agent, never in code, logs or URLs.
It is used to compute your fits. You can cancel a running fit and discard the session with DELETE /session/{id}. Data handling is governed by the API Terms of Use and our privacy policy.
Beta. P34 returns quantities and predicted profit; it places no orders and does not promise profit. You own the decisions, the capital and the results. Use of the API is governed by the API Terms of Use, presented in the console.