# Date and Age Calculator (`mangudai/date-age-calculator`) Actor

Calculate age from a birth date, the number of days between two dates, or add and subtract years, months, weeks and days. Every row returns years, months, days, running totals, weekdays, the next birthday and the zodiac sign. Runs fully offline with no API key.

- **URL**: https://apify.com/mangudai/date-age-calculator.md
- **Developed by:** [Mangudäi](https://apify.com/mangudai) (community)
- **Categories:** Developer tools, Automation, Open source
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Date and Age Calculator: age, days between dates, add or subtract time

Work out how old someone is, how many days sit between two dates, or what the date will be 90 days from now. Every calculation runs offline on the Python standard library, so there is no API key, no rate limit, and nothing that can break when a website changes.

Send one calculation or a hundred in a single run. Each one comes back as a row in a clean table you can export to CSV, Excel, JSON or XML.

### What it does

Four calculation types, set with the `type` field:

`age` gives the age from a birth date to today or to any reference date, plus the next birthday, days until it, the age being turned, the western zodiac sign and the Chinese zodiac animal.

`difference` gives the full gap between two dates: calendar years, months and days, plus totals in months, weeks, days, hours, minutes and seconds.

`add` moves a date forward by years, months, weeks, days, hours or minutes.

`subtract` moves a date backward by the same units.

Month arithmetic follows the calendar rather than a fixed 30 days, so 31 January plus one month lands on 28 or 29 February, and a 29 February birthday rolls to 1 March in non-leap years.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `calculations` | array | One object per calculation. Required. |
| `referenceDate` | string | Treated as today for `age` rows with no `toDate`. Defaults to the current UTC date. |

Fields inside each calculation object:

| Field | Description |
| --- | --- |
| `type` | `age`, `difference`, `add` or `subtract` |
| `label` | Your own name for the row, copied to the output |
| `date` | Start date, or birth date for `age`. `YYYY-MM-DD` or a full ISO timestamp |
| `toDate` | Second date for `difference`, or the as-of date for `age` |
| `years`, `months`, `weeks`, `days`, `hours`, `minutes` | Duration for `add` and `subtract` |

Example input:

```json
{
  "calculations": [
    { "label": "Age from birth date", "type": "age", "date": "1990-05-15" },
    { "label": "Contract length", "type": "difference", "date": "2026-01-01", "toDate": "2026-12-31" },
    { "label": "Invoice due", "type": "add", "date": "2026-07-18", "days": 30 },
    { "label": "Eighteen months ago", "type": "subtract", "date": "2026-07-18", "months": 18 }
  ]
}
````

### Output

One row per calculation:

| Field | Description |
| --- | --- |
| `label` | Your label |
| `type` | Calculation type |
| `startDate`, `endDate` | The two dates used |
| `resultDate` | The computed date for `add` and `subtract` |
| `years`, `months`, `days` | Calendar breakdown |
| `humanReadable` | The same breakdown in words, for example `36 years, 2 months and 3 days` |
| `totalMonths`, `totalWeeks`, `totalDays`, `totalHours`, `totalMinutes`, `totalSeconds` | Whole-unit totals |
| `weeksAndDays` | Totals as weeks plus leftover days |
| `startWeekday`, `endWeekday` | Day of the week for each date |
| `nextBirthday`, `daysUntilNextBirthday`, `ageAtNextBirthday` | Birthday fields, `age` type only |
| `zodiacSign`, `chineseZodiac` | Signs from the birth date, `age` type only |
| `datesReversed` | True when the second date falls before the first |
| `error` | Reason a row failed, otherwise empty |

Sample row:

```json
{
  "label": "Age from birth date",
  "type": "age",
  "startDate": "1990-05-15",
  "endDate": "2026-07-18",
  "years": 36,
  "months": 2,
  "days": 3,
  "humanReadable": "36 years, 2 months and 3 days",
  "totalDays": 13213,
  "totalWeeks": 1887,
  "startWeekday": "Tuesday",
  "nextBirthday": "2027-05-15",
  "daysUntilNextBirthday": 301,
  "ageAtNextBirthday": 37,
  "zodiacSign": "Taurus",
  "chineseZodiac": "Horse"
}
```

### Uses

Age verification and eligibility checks on a list of birth dates. Contract, lease and subscription lengths. Invoice and payment due dates. Project timelines and countdowns to a launch. Retention cohorts measured in days since signup. Bulk cleaning of date columns exported from a CRM.

### Notes

A bad date does not stop the run. That row comes back with an `error` message and the rest continue.

All arithmetic is done in naive UTC. Timestamps carrying an offset are converted to UTC first.

Billing is pay per event: a small charge per actor start and a charge per result row.

# Actor input Schema

## `calculations` (type: `array`):

One object per calculation. Set type to age, difference, add or subtract. Use date for the start (birth date for age), toDate for the second date, and years, months, weeks, days, hours or minutes for add and subtract. Dates accept YYYY-MM-DD or a full ISO timestamp.

## `referenceDate` (type: `string`):

Date used as today for age calculations that have no toDate. Leave empty to use the current UTC date.

## Actor input object example

```json
{
  "calculations": [
    {
      "label": "Age from birth date",
      "type": "age",
      "date": "1990-05-15"
    },
    {
      "label": "Days between two dates",
      "type": "difference",
      "date": "2026-01-01",
      "toDate": "2026-12-31"
    },
    {
      "label": "90 days from today",
      "type": "add",
      "date": "2026-07-18",
      "days": 90
    },
    {
      "label": "18 months ago",
      "type": "subtract",
      "date": "2026-07-18",
      "months": 18
    }
  ]
}
```

# Actor output Schema

## `results` (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 = {
    "calculations": [
        {
            "label": "Age from birth date",
            "type": "age",
            "date": "1990-05-15"
        },
        {
            "label": "Days between two dates",
            "type": "difference",
            "date": "2026-01-01",
            "toDate": "2026-12-31"
        },
        {
            "label": "90 days from today",
            "type": "add",
            "date": "2026-07-18",
            "days": 90
        },
        {
            "label": "18 months ago",
            "type": "subtract",
            "date": "2026-07-18",
            "months": 18
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mangudai/date-age-calculator").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 = { "calculations": [
        {
            "label": "Age from birth date",
            "type": "age",
            "date": "1990-05-15",
        },
        {
            "label": "Days between two dates",
            "type": "difference",
            "date": "2026-01-01",
            "toDate": "2026-12-31",
        },
        {
            "label": "90 days from today",
            "type": "add",
            "date": "2026-07-18",
            "days": 90,
        },
        {
            "label": "18 months ago",
            "type": "subtract",
            "date": "2026-07-18",
            "months": 18,
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("mangudai/date-age-calculator").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "calculations": [
    {
      "label": "Age from birth date",
      "type": "age",
      "date": "1990-05-15"
    },
    {
      "label": "Days between two dates",
      "type": "difference",
      "date": "2026-01-01",
      "toDate": "2026-12-31"
    },
    {
      "label": "90 days from today",
      "type": "add",
      "date": "2026-07-18",
      "days": 90
    },
    {
      "label": "18 months ago",
      "type": "subtract",
      "date": "2026-07-18",
      "months": 18
    }
  ]
}' |
apify call mangudai/date-age-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mangudai/date-age-calculator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Date and Age Calculator",
        "description": "Calculate age from a birth date, the number of days between two dates, or add and subtract years, months, weeks and days. Every row returns years, months, days, running totals, weekdays, the next birthday and the zodiac sign. Runs fully offline with no API key.",
        "version": "0.0",
        "x-build-id": "6wSNr6p30jqFRKn1f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mangudai~date-age-calculator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mangudai-date-age-calculator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/mangudai~date-age-calculator/runs": {
            "post": {
                "operationId": "runs-sync-mangudai-date-age-calculator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/mangudai~date-age-calculator/run-sync": {
            "post": {
                "operationId": "run-sync-mangudai-date-age-calculator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "calculations"
                ],
                "properties": {
                    "calculations": {
                        "title": "Calculations",
                        "type": "array",
                        "description": "One object per calculation. Set type to age, difference, add or subtract. Use date for the start (birth date for age), toDate for the second date, and years, months, weeks, days, hours or minutes for add and subtract. Dates accept YYYY-MM-DD or a full ISO timestamp."
                    },
                    "referenceDate": {
                        "title": "Reference date",
                        "type": "string",
                        "description": "Date used as today for age calculations that have no toDate. Leave empty to use the current UTC date."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
