# Deterministic Math Expression Evaluator Tool (`rainminer/math-tool`) Actor

Evaluate mathematical expressions deterministically for AI agents and automations. Supports arithmetic, functions, and variables via a safe expression parser. Designed for AI agents for concise, deterministic, and accurate math outputs. Use over MCP, API, or the Apify Console.

- **URL**: https://apify.com/rainminer/math-tool.md
- **Developed by:** [rainminer](https://apify.com/rainminer) (community)
- **Categories:** AI, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 1,000 expressions

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Math Tool — Deterministic Math Calculator for AI Agents

**Math Tool** is a lightweight Apify Actor that lets **AI agents**, LLM workflows, and automations evaluate **mathematical expressions** with **deterministic, reproducible results**. Offload arithmetic, powers, roots, and trigonometry from your agent to a dedicated calculator instead of relying on probabilistic model output.

Run it from Apify Console, the **Apify API**, scheduled jobs, or agent frameworks that call external tools. Results are returned as structured **JSON** you can pipe into the next step of any workflow.

### What is Math Tool?

Math Tool evaluates one or more math expressions in a single run and returns exact numeric answers. It uses the [expr-eval](https://github.com/silentmatt/expr-eval) parser — the same engine behind many agent math utilities — so expressions like `2 + 2`, `sqrt(16)`, `sin(pi / 2)`, and `3^4` are parsed and calculated server-side, not guessed by an LLM.

**Ideal for:** AI agents, RAG pipelines, finance automations, engineering calculators, data validation, and any workflow that needs reliable math over the Apify API.

### What can this Math Tool do?

- Evaluate **multiple expressions** in one API call
- Return **one JSON dataset row per expression** with `expression`, `result`, and `error`
- Support **arithmetic**, **exponents**, **roots**, **trigonometry**, **logarithms**, and **variables**
- Run in **milliseconds** on minimal compute — no browser, no proxy, no scraping
- Integrate via **Apify API**, webhooks, schedules, and third-party automation platforms
- Export results as **JSON**, **CSV**, or **Excel** from the dataset

### Why use Math Tool for AI agents?

Large language models often hallucinate numbers. Giving your agent a **deterministic math tool** on Apify means:

1. **Accuracy** — Calculations are computed, not inferred.
2. **Reproducibility** — The same expression always yields the same result.
3. **Auditability** — Every run stores input expressions and outputs in a dataset.
4. **Scalability** — Call the Actor from thousands of agent runs via API without hosting your own calculator.

Pair Math Tool with other Apify Actors to build agent workflows: scrape data, calculate metrics, and push results anywhere.

### How do I use Math Tool from an AI agent?

1. Open [Math Tool on Apify Store](https://apify.com) or run it from Apify Console.
2. Pass an array of **expressions** in the input.
3. Read one dataset row per expression from the run output or via the Apify API.

#### API example

```json
{
  "expressions": ["2 + 2", "sqrt(16)", "(10 + 5) * 3", "log(100)"]
}
```

#### Output example

Each expression produces one dataset row:

```json
[
  { "expression": "2 + 2", "result": 4, "error": null },
  { "expression": "sqrt(16)", "result": 4, "error": null },
  { "expression": "(10 + 5) * 3", "result": 45, "error": null },
  { "expression": "log(100)", "result": 4.605170185988092, "error": null }
]
```

Download the dataset in **JSON**, **CSV**, **HTML**, or **Excel** from the run overview.

### Supported expression syntax

Math Tool uses **expr-eval**. Common operators and functions:

| Category       | Examples                                                       |
| -------------- | -------------------------------------------------------------- |
| Arithmetic     | `+`, `-`, `*`, `/`, `%`, `^`                                   |
| Grouping       | `(`, `)`                                                       |
| Constants      | `PI`, `E`, `pi`, `e`, `true`, `false`                          |
| Roots & powers | `sqrt(x)`, `cbrt(x)`, `x^y`                                    |
| Trigonometry   | `sin(x)`, `cos(x)`, `tan(x)`, `asin(x)`, `acos(x)`, `atan(x)`  |
| Logarithms     | `log(x)`, `ln(x)`, `log10(x)`                                  |
| Rounding       | `abs(x)`, `ceil(x)`, `floor(x)`, `round(x)`                    |
| Variables      | `x = 5; x * 2` (assign then use in the same expression string) |

Full parser documentation: [expr-eval on GitHub](https://github.com/silentmatt/expr-eval).

### Input

Math Tool has the following input options. Click the **Input** tab in Apify Console for field descriptions.

| Field         | Type       | Description                                       |
| ------------- | ---------- | ------------------------------------------------- |
| `expressions` | `string[]` | Required. One or more math expressions to evaluate. |

### How much does Math Tool cost?

Math Tool is extremely lightweight — no browser, no proxies, and typically finishes in under one second. A run consumes a fraction of a Compute Unit, so you can evaluate thousands of expressions on Apify's free tier. Exact cost depends on your Apify plan and run frequency.

### FAQ

#### Is Math Tool safe for agent tool calling?

Yes. Expressions are parsed and evaluated by expr-eval in an isolated Apify container. There is no arbitrary code execution — only supported math syntax is accepted.

#### Can I call Math Tool from Python or JavaScript agents?

Yes. Use the [Apify API](https://docs.apify.com/api/v2) or official Apify client libraries to start a run, pass `expressions`, and read results from the default dataset.

#### What happens when an expression fails?

Failed expressions do not stop the run. Each row includes `result: null` and an `error` message. Other expressions in the same batch are still evaluated.

```json
[
  { "expression": "2 + 2", "result": 4, "error": null },
  {
    "expression": "foo(bar)",
    "result": null,
    "error": "undefined variable: foo"
  }
]
```

#### Why not let the LLM calculate directly?

LLMs approximate math and can be wrong on large numbers, floating-point edge cases, or multi-step formulas. Math Tool gives agents a **reliable calculator API** on Apify.

### Integrations

- **Apify API** — Start runs and fetch dataset items programmatically
- **Webhooks** — Trigger downstream steps when evaluation completes
- **Schedules** — Recompute metrics on a cron
- **Make, Zapier, n8n** — Connect agent workflows without custom hosting

### Support

Open an issue on the Actor page if you need additional functions. Math Tool is designed to stay minimal and fast for agent use cases.

# Actor input Schema

## `expressions` (type: `array`):

Mathematical expressions to evaluate. Supports arithmetic, functions, and variables. See the README for supported syntax.

## Actor input object example

```json
{
  "expressions": [
    "2 + 2",
    "sqrt(16)",
    "sin(pi / 2)",
    "3^4"
  ]
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "expressions": [
        "2 + 2",
        "sqrt(16)",
        "sin(pi / 2)",
        "3^4"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("rainminer/math-tool").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "expressions": [
        "2 + 2",
        "sqrt(16)",
        "sin(pi / 2)",
        "3^4",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("rainminer/math-tool").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "expressions": [
    "2 + 2",
    "sqrt(16)",
    "sin(pi / 2)",
    "3^4"
  ]
}' |
apify call rainminer/math-tool --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rainminer/math-tool"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/sh2QIIaq9R1mK4tXH/builds/Z0ZsZcGg7wwu1VkyM/openapi.json