Build and Scale NLH Solving with the Deepsolver API

Running an occasional poker calculation is relatively straightforward. Generating thousands of solutions, processing their results, and integrating them into a commercial product is a very different challenge.

The Deepsolver API provides direct access to our NLH solving infrastructure through a scalable HTTP API. It allows you to generate custom solutions without building and maintaining your own solving engine.

From defining game trees to retrieving detailed strategy data, you can automate the entire process and integrate it into your existing workflow or application.

Who Is the Deepsolver API For?

The Deepsolver API is built for businesses and teams that need to automate or scale NLH calculations. If you are an individual player looking to analyze a few hands, you will find everything you need in the standard Deepsolver application.

The API is particularly well suited if you want to run calculations programmatically, generate large solution libraries, or integrate solver data into your own product. You can use it to build:

• poker training applications;
• solver-powered educational platforms;
• automated hand analysis tools;
• large libraries of precomputed solutions;
• aggregate reports and strategy databases;
• private research projects;
• commercial white-label products.

You can use the API as the calculation layer behind a completely separate product. There are no restrictions on reselling or white-labeling the service, provided it is not used to offer real-time assistance during live play.

Automate the Entire Solving Process

Using a traditional solver interface works well when you are analyzing individual situations. However, manually configuring every calculation becomes impractical when your project requires thousands of boards, ranges, stack depths, or game trees.

The Deepsolver API allows you to automate the full process:

1. Define the game tree.
2. Submit the ranges, board, and calculation parameters.
3. Schedule the solve.
4. Monitor its progress.
5. Retrieve the completed results.
6. Store or process the data in your own system.

You can place more than 10,000 jobs in a queue at once. They are processed automatically as GPU capacity becomes available, allowing you to prepare large batches without scheduling every calculation separately.

This makes the API suitable for building complete strategy libraries or performing systematic research across many configurations.

Full Control Over the Game Tree

Different poker products often require different abstractions. Your training tool may use only one bet size per street, while a research platform might need several bet and raise sizes, donk bets, or precisely defined action sequences.

The API allows you to control elements such as:

• starting pot size;
• effective stack depth;
• available streets;
• bet and raise sizes;
• donk bet options;
• all-in thresholds;
• specific paths through the game tree;
• the number of solver iterations.

This flexibility allows you to reproduce your existing abstraction or create trees tailored to a particular game, player pool, or training objective.

The current API supports heads-up NLH postflop calculations. Multiway trees are not yet available.

Detailed Results for Every Hand

A completed calculation can provide much more than an overall strategy summary. Your results can include:

• expected value;
• equity;
• action frequencies;
• per-node strategy matrices;
• convergence statistics;
• calculation time;
• a copy of the original configuration.

EV and equity can be returned for all 1,326 Hold’em starting-hand combinations. You can also request strategy matrices for selected nodes, allowing you to retrieve only the data your application needs.

Results are available as nested JSON structures or compact binary arrays for more efficient post-processing. This makes the output suitable for both direct presentation and further analysis with tools such as NumPy.

You can use the returned data to create your own:

• range grids;
• strategy charts;
• reports;
• training exercises;
• hand breakdowns;
• database queries;
• aggregate analyses.

In other words, Deepsolver provides the underlying calculations, while you remain free to decide how the results should be processed and presented.

Fast, Scalable GPU Infrastructure

A typical calculation takes approximately 2–8 seconds, depending on factors such as tree size, hardware, and the requested number of iterations.

Each active solve uses one GPU. With one GPU, you can run one calculation at a time. Adding more GPUs increases the number of simultaneous solves, giving you a straightforward way to expand your computing capacity as demand grows.

You can also select a higher GPU tier when faster solving is required. The exact hardware configuration can be adjusted to your expected volume, tree complexity, and preferred deployment region.

This allows you to use the API for projects ranging from smaller strategy databases to platforms processing large numbers of calculations every day.

Dedicated Infrastructure and Data Control

With a subscription, you receive a dedicated environment instead of sharing your production infrastructure with other customers.

Your setup can include:

• a separate project and VPC;
• regional deployment;
• individual API tokens;
• HTTPS encryption;
• optional IP allow-listing;
• monitoring and alerts;
• managed object storage;
• your own GCS or S3 storage.

By default, Deepsolver can manage your result storage for the duration of your active subscription. Alternatively, you can write the results directly to your own cloud bucket.

This gives you greater control over your data while removing the need to deploy and maintain the complete solving infrastructure yourself.

Build Your Product Without Building a Solver

Developing a poker solver requires more than implementing a calculation algorithm. A production-ready system also needs GPU infrastructure, task queues, result storage, monitoring, authentication, security, deployment automation, and ongoing maintenance.

Recreating this entire stack can require a significant investment before you can begin working on the product your users will actually see.

With the Deepsolver API, you can focus on areas such as:

• product design;
• user experience;
• strategy presentation;
• educational features;
• data analysis;
• customer acquisition.

Deepsolver handles the calculation and infrastructure layer behind the scenes. Bespoke development and additional integration support are also available if you need help connecting the API to your existing system.

API Pricing Options

You can choose from several subscription tiers depending on your expected number of calculations and required capacity. Each subscription includes one GPU server, managed platform operations, and a monthly storage allowance.

Current monthly plans range from the Builder plan, which includes 50,000 calls, to the Enterprise plan with unlimited API usage. You receive a 25% discount when choosing an annual contract.

If you do not yet require dedicated infrastructure, you can also purchase calculations on demand in packs of 10,000. This provides a simpler entry point for smaller projects or occasional batches.

A paid demo includes 20,000 API calls on Deepsolver’s shared production infrastructure. If you later move to a subscription, the demo fee will be credited toward your first invoice.

When choosing your setup, consider:

• your expected calculation volume;
• required parallelism;
• tree complexity;
• preferred server region;
• storage requirements;
• the selected GPU tier.

Test the API with Your Own Use Case

The best way to evaluate any solver infrastructure is to run it against the workload you actually expect it to handle. Think through how many calculations your project will need, how fast they need to come back, and what data you want out the other end — our team can help you match that to the right plan and infrastructure setup.

Whether you're building a solver-powered training tool, a large NLH library, an automated research pipeline, or a white-label product, the Deepsolver API gives you the calculation layer to turn the idea into a scalable service.

Full technical details, request/response examples, and current pricing are available on the Deepsolver API page.