I Needed an LP Solver but Gurobi Costs $10K/yr — So I Built an API for $9/month

The $10,000 Pricing Page That Says Nothing

Last year I needed to solve a scheduling problem. Nothing exotic -- a constrained optimization where you have limited resources, competing priorities, and a function to maximize. The kind of thing that operations research solved decades ago with linear programming.

So I went looking for an LP solver I could call from a web service. I found Gurobi, the gold standard. Clicked "Pricing." And landed on a page with zero numbers and a "Contact Sales" button.

I'm not the only one who finds this frustrating. If you've spent any time in optimization forums, you've seen the same complaints echoed over and over:

"The best MIP solvers (CPLEX, GUROBI, FICO) are all extremely expensive unless you're an academic."

"Gurobi is super fast, but the licensing was just impossible."

"I just hate it when you go to the pricing page and there's NO PRICING. None."

After some digging, the numbers surfaced: Gurobi runs $10,000 to $50,000 per year depending on your configuration. IBM CPLEX starts at $3,420/year for a single user. These are tools designed for Fortune 500 logistics departments, not a developer building a scheduling feature for a SaaS app.

The licensing model makes things worse. Gurobi licenses are tied to specific machines. One HN commenter described how their company bought "4 old 24-core Xeons off eBay" just to avoid paying for additional license seats. Another pointed out the fundamental incompatibility with modern infrastructure:

"The inability to do something like have autoscaling containers using Gurobi was ultimately the dealbreaker."

So I built my own. Not a solver from scratch -- that would be foolish. I wrapped HiGHS, an open-source LP/MIP solver that's already proven in production, into a hosted API that anyone can call with a single HTTP request. No license files. No sales calls. No seat counting.

What Are You Actually Paying $10K/Year For?

If you're not from an operations research background, linear programming might sound abstract. It isn't. Here's what it does in plain English:

Linear programming (LP) finds the best outcome given constraints. You have some quantity you want to maximize or minimize (profit, cost, time), and you have limits on what you can do (budget, hours, materials). An LP solver finds the mathematically optimal answer.

Mixed-integer programming (MIP) is the same thing, but some of your variables have to be whole numbers. You can't produce 3.7 chairs. You produce 3 or 4.

These problems are everywhere:

• Manufacturing: Which products should a factory make this week to maximize profit, given limited labor and materials?
• Logistics: What's the cheapest way to route 50 delivery trucks across 200 stops?
• Scheduling: How do you assign 30 nurses to 3 shifts across 7 days while respecting labor laws and preferences?
• Finance: How do you allocate a portfolio across 20 assets to maximize return while keeping risk below a threshold?

The mathematical theory behind LP solvers is well-established. The simplex method dates to 1947. Interior-point methods are from the 1980s. Branch-and-bound for MIP has been refined for decades. What you're paying for with commercial solvers isn't novel math -- it's engineering: hand-tuned heuristics, presolve routines, and parallelization that shave seconds off industrial-scale problems with millions of variables.

But most developers don't have millions of variables. They have dozens. Maybe hundreds. And for those problems, the gap between a $50,000/year commercial solver and a free open-source one is measured in microseconds, not hours.

The Solver Landscape in 2026

Here's an honest comparison of what's available:

A few notes on this table:

Gurobi and CPLEX are genuinely excellent solvers. If you're solving problems with 100,000+ variables and need cutting-edge performance, they earn their price. But their licensing model was designed for a world where software ran on owned hardware, not ephemeral containers.

OR-Tools is Google's open-source optimization suite. It's powerful and free, but the documentation is... a known problem. The OR-Tools tag on Stack Overflow is a graveyard of unanswered questions. Getting it running in production requires compiling native binaries and managing a Python environment.

HiGHS is the solver engine I chose to build on. It's open-source, developed at the University of Edinburgh, and won the 2024 DIMACS challenge for LP solvers. It runs as a WASM module, meaning no native compilation, no platform-specific binaries. The catch: it's a library, not a service. You have to host it yourself.

The gap in this landscape is obvious. If you want a solver you can call from any language over HTTP with zero setup, your options are limited to either paying enterprise prices or building and hosting the infrastructure yourself.

A Real Example: Factory Scheduling

Let's walk through a concrete LP problem.

You run a furniture workshop. You make two products: chairs and tables. Each chair earns $45 profit. Each table earns $80 profit. You want to maximize weekly profit.

But you have constraints:

• Labor: You have 400 hours of labor per week. A chair takes 5 hours. A table takes 20 hours.
• Wood: You have 450 units of wood per week. A chair uses 10 units. A table uses 15 units.
• Capacity: You can't make more than 100 of either product per week.

Mathematically, this is:

Maximize:    45x + 80y
Subject to:  5x + 20y ≤ 400    (labor)
             10x + 15y ≤ 450   (wood)
             0 ≤ x ≤ 100       (chair capacity)
             0 ≤ y ≤ 100       (table capacity)
             x, y ∈ integers

Where x is the number of chairs and y is the number of tables.

You could solve this by graphing the feasible region and checking corner points. Or you could send one API call (LP/MIP is a premium tool — get a key in 30 seconds at oraclaw signup):

curl -X POST https://oraclaw-api.onrender.com/api/v1/solve/constraints \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "direction": "maximize",
    "objective": { "chairs": 45, "tables": 80 },
    "variables": [
      { "name": "chairs", "lower": 0, "upper": 100, "type": "integer" },
      { "name": "tables", "lower": 0, "upper": 100, "type": "integer" }
    ],
    "constraints": [
      { "name": "labor_hours", "coefficients": { "chairs": 5, "tables": 20 }, "upper": 400 },
      { "name": "wood_units", "coefficients": { "chairs": 10, "tables": 15 }, "upper": 450 }
    ]
  }'

Response:

{
  "status": "optimal",
  "objectiveValue": 2200,
  "variables": { "chairs": 24, "tables": 14 }
}

The optimal answer: make 24 chairs and 14 tables for a maximum weekly profit of $2,200.

Verify the constraints hold:

• Labor: 5(24) + 20(14) = 120 + 280 = 400 ≤ 400 ✓ (binding)
• Wood: 10(24) + 15(14) = 240 + 210 = 450 ≤ 450 ✓ (binding)

Both constraints are binding at the optimum — exactly where you'd expect a true LP solution to land. HiGHS explores the full feasible polytope and returns the corner that maximises the objective, not a heuristic guess.

What makes this interesting for developers isn't the math — it's the interface. No library installation. No language-specific SDK. No binary compilation. One HTTP call and you have the answer. Use it from Python, JavaScript, Go, Ruby, a shell script, or an AI agent that constructs the request autonomously.

When NOT to Use This

I want to be direct about the limitations, because choosing the wrong solver for your problem is worse than paying too much for the right one.

Use Gurobi or CPLEX when:

• Your problem has 10,000+ variables and you need solutions in seconds, not minutes
• You're running millions of solves per day in a batch processing pipeline
• You need advanced features like quadratic programming (QP), second-order cone programming (SOCP), or nonlinear optimization
• You have dedicated operations research staff who will tune solver parameters
• Your company's revenue depends on shaving 2% off logistics costs at industrial scale

Use an API-based solver when:

• Your problems are small to medium (dozens to low thousands of variables)
• You need optimization as a feature, not as the core product
• You're a startup or indie developer who can't justify $10K/year for a solver license
• You want to call optimization from a web service, mobile app, or AI agent
• You need something working in minutes, not days of setup

The honest truth is that Gurobi is faster on large MIP problems. That's why companies pay $50,000/year for it. But "faster" means going from 0.8 seconds to 0.3 seconds on a 50,000-variable problem. For a 50-variable scheduling problem, both solvers return in under a millisecond. You're paying for headroom you may never need.

The MCP Angle: Your AI Agent Calls the Solver Itself

If you're running an agent in Claude Desktop, Cursor, or Cline, the LP/MIP solver is exposed as an MCP tool. Drop this into your claude_desktop_config.json:

{
  "mcpServers": {
    "oraclaw": {
      "command": "npx",
      "args": ["-y", "@oraclaw/mcp-server"],
      "env": { "ORACLAW_API_KEY": "your-key-here" }
    }
  }
}

Restart your client and you can literally type:

"Maximise 45·chairs + 80·tables, subject to 5·chairs + 20·tables ≤ 400 labour hours and 10·chairs + 15·tables ≤ 450 wood units. Both must be non-negative integers."

The agent calls solve_constraints itself, gets back the structured optimum + objective value, and explains it. No more LLMs guessing at integer programs they can't actually solve.

Beyond LP/MIP, the OraClaw MCP server ships 17 tools total — bandits, Monte Carlo, scheduling, Bayesian belief updates, ensemble consensus, pathfinding, scoring, time-series forecast, anomaly detection, graph analytics, CMA-ES, portfolio risk. All with explicit input + output JSON schemas so your agent knows exactly what it gets back.

The Bottom Line

Linear programming is a solved problem. The simplex method is nearly 80 years old. The mathematics don't change based on what you pay for a license.

What changes is access.

Gurobi charges $10,000+/year and won't even show you the price. CPLEX wants $285/user/month. Both require license files, seat management, and enterprise sales cycles. Deploying them in containers is either painful or impossible.

The alternative: an API call at $0.005 per request, or $9/month for 50K calls on the Starter plan. No sales call, no license file, no seat counting. Run it from any language, any platform, any container orchestrator — or have your AI agent call it directly via MCP.

The solver underneath is HiGHS — the same open-source engine winning LP benchmarks. Wrapped in a REST API for simplicity and exposed as an MCP tool for AI agents.

If you're building something that needs optimization and you're not a Fortune 500 logistics department, you shouldn't have to navigate enterprise sales to solve a linear program.

Get Started

• Get an API key (1 email): oraclaw signup — instant key, 1,000 calls/day on pay-per-call ($0.005/call), upgrade to Starter $9/mo for 50K/month
• Try free tools without a key: the API has 11 free endpoints (bandits, Monte Carlo, scheduling, pathfinding, scoring, Bayesian) — curl https://oraclaw-api.onrender.com/api/v1/optimize/bandit ...
• Use it from your AI agent: npm install @oraclaw/mcp-server or paste the MCP config above into Claude Desktop / Cursor / Cline
• Source + 17-tool docs: github.com/Whatsonyourmind/oraclaw (MIT licensed)
• Live API: oraclaw-api.onrender.com

The math is the same. The price shouldn't be.