# AI Data Enricher (`umischael/ai-data-enricher`) Actor

Enrich any dataset with AI-powered analysis: sentiment, summary, categories, keywords, entities, language, and tone. Works with Apify datasets, CSV files, or manual JSON input.

- **URL**: https://apify.com/umischael/ai-data-enricher.md
- **Developed by:** [Mischael RADABANORO](https://apify.com/umischael) (community)
- **Categories:** AI, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## AI Data Enricher

Enrich any dataset with AI-powered analysis — no coding required.

**Sentiment · Summary · Categories · Keywords · Entities · Language · Tone**

Add 7 AI-generated columns to any dataset in one click. Works with Apify datasets, CSV files, or manual JSON input.

---

### 🚀 How it works

1. **Pick your data** — choose an existing Apify dataset, upload a CSV, or paste JSON
2. **Select the text field** — tell the Actor which column contains the text to analyze
3. **Choose enrichments** — pick one or more: sentiment, summary, categories, keywords, entities, language, tone
4. **Provide your OpenAI API key** — the Actor uses **your own key** (you control costs — bring your own)
5. **Run** — enriched data appears as new columns (prefixed `ai_`) in the output dataset

### 📊 Example

**Input:**
```json
{"text": "This product is absolutely amazing! I've been using it for weeks and it exceeded all my expectations."}
````

**Output:**

```json
{
  "text": "This product is absolutely amazing!...",
  "ai_sentiment": "positive",
  "ai_summary": "Customer is very satisfied with the product, praising its build quality and performance.",
  "ai_categories": ["Consumer Electronics", "Customer Review", "Product Satisfaction"],
  "ai_keywords": ["amazing", "exceeded expectations", "build quality", "top-notch"],
  "ai_entities": [],
  "ai_language": "en",
  "ai_tone": "enthusiastic"
}
```

### 🧠 Enrichment types

| Enrichment | Description | Output type |
|---|---|---|
| `sentiment` | Positive / negative / neutral classification | `string` |
| `summary` | 1-2 sentence AI summary | `string` |
| `categories` | 2-5 relevant category labels | `array[string]` |
| `keywords` | 5-10 key phrases extracted | `array[string]` |
| `entities` | Named entities (people, places, brands) | `array[string]` |
| `language` | Detected language (ISO 639-1 code) | `string` |
| `tone` | Emotional tone (enthusiastic, formal, urgent…) | `string` |

### ⚙️ Technical details

- **Model**: Uses OpenAI GPT-4o-mini (fast, cheap, multilingual)
- **Processing**: Items are processed sequentially with individual LLM calls
- **Error handling**: Items that fail enrichment get `null` values — your original dataset is never lost
- **Output**: Same schema as input + new `ai_*` columns + overall enrichment summary

### 🔑 API key

This Actor requires an **OpenAI API key** with access to `gpt-4o-mini` (or any chat model). You can use any model from the OpenAI models list.

Get your key at: https://platform.openai.com/api-keys

### 📥 Input sources supported

- ✅ **Apify dataset** — reference an existing dataset ID
- ✅ **CSV URL** — public CSV file URL (first row = headers)
- ✅ **Manual JSON** — paste items directly in the input UI

### 💰 Pricing

**Free to use.** You only pay for your own OpenAI API usage.

*Apify platform usage credits may apply (see your Apify plan for details).*

# Actor input Schema

## `dataSource` (type: `string`):

Where to read the input data from

## `manualData` (type: `array`):

JSON array of objects to enrich when dataSource is 'manual'. Each object must contain the textField specified below.

## `datasetId` (type: `string`):

The ID of an existing Apify dataset to read data from (when dataSource = 'dataset')

## `csvUrl` (type: `string`):

Public URL to a CSV file (when dataSource = 'csv'). First row must be headers.

## `textField` (type: `string`):

The name of the field/column that contains the text to analyze (e.g. 'text', 'content', 'review', 'description')

## `enrichments` (type: `array`):

Select one or more AI enrichment types to apply to the text field

## `apiKey` (type: `string`):

Your OpenAI API key. Required to run LLM enrichment. Keep this private.

## `model` (type: `string`):

OpenAI model to use for enrichment. gpt-4o-mini is fast and cheap; gpt-4o is more accurate.

## Actor input object example

```json
{
  "dataSource": "manual",
  "manualData": [
    {
      "text": "This product is amazing! I love the quality and durability.",
      "id": 1
    }
  ],
  "textField": "text",
  "enrichments": [
    "sentiment"
  ],
  "model": "gpt-4o-mini"
}
```

# Actor output Schema

## `total_input` (type: `string`):

Total number of input items

## `total_enriched` (type: `string`):

Number of items successfully enriched

## `enrichments_applied` (type: `string`):

List of enrichment types applied

## `model_used` (type: `string`):

OpenAI model used

# 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 = {
    "manualData": [
        {
            "text": "This product is amazing! I love the quality and durability.",
            "id": 1
        }
    ],
    "datasetId": "",
    "csvUrl": "",
    "textField": "text",
    "apiKey": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("umischael/ai-data-enricher").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 = {
    "manualData": [{
            "text": "This product is amazing! I love the quality and durability.",
            "id": 1,
        }],
    "datasetId": "",
    "csvUrl": "",
    "textField": "text",
    "apiKey": "",
}

# Run the Actor and wait for it to finish
run = client.actor("umischael/ai-data-enricher").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 '{
  "manualData": [
    {
      "text": "This product is amazing! I love the quality and durability.",
      "id": 1
    }
  ],
  "datasetId": "",
  "csvUrl": "",
  "textField": "text",
  "apiKey": ""
}' |
apify call umischael/ai-data-enricher --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=umischael/ai-data-enricher",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Data Enricher",
        "description": "Enrich any dataset with AI-powered analysis: sentiment, summary, categories, keywords, entities, language, and tone. Works with Apify datasets, CSV files, or manual JSON input.",
        "version": "0.1",
        "x-build-id": "bANZaecGUL1TtPzu7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/umischael~ai-data-enricher/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-umischael-ai-data-enricher",
                "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/umischael~ai-data-enricher/runs": {
            "post": {
                "operationId": "runs-sync-umischael-ai-data-enricher",
                "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/umischael~ai-data-enricher/run-sync": {
            "post": {
                "operationId": "run-sync-umischael-ai-data-enricher",
                "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": [
                    "textField",
                    "enrichments",
                    "apiKey"
                ],
                "properties": {
                    "dataSource": {
                        "title": "Data source",
                        "enum": [
                            "manual",
                            "dataset",
                            "csv"
                        ],
                        "type": "string",
                        "description": "Where to read the input data from",
                        "default": "manual"
                    },
                    "manualData": {
                        "title": "Manual data",
                        "type": "array",
                        "description": "JSON array of objects to enrich when dataSource is 'manual'. Each object must contain the textField specified below."
                    },
                    "datasetId": {
                        "title": "Apify dataset ID",
                        "type": "string",
                        "description": "The ID of an existing Apify dataset to read data from (when dataSource = 'dataset')"
                    },
                    "csvUrl": {
                        "title": "CSV file URL",
                        "type": "string",
                        "description": "Public URL to a CSV file (when dataSource = 'csv'). First row must be headers."
                    },
                    "textField": {
                        "title": "Text field name",
                        "type": "string",
                        "description": "The name of the field/column that contains the text to analyze (e.g. 'text', 'content', 'review', 'description')"
                    },
                    "enrichments": {
                        "title": "Enrichments to apply",
                        "type": "array",
                        "description": "Select one or more AI enrichment types to apply to the text field",
                        "items": {
                            "type": "string",
                            "enum": [
                                "sentiment",
                                "summary",
                                "categories",
                                "keywords",
                                "entities",
                                "language",
                                "tone"
                            ],
                            "enumTitles": [
                                "Sentiment (very_negative → very_positive)",
                                "Summary (1-2 sentence summary)",
                                "Categories (up to 3 topic categories)",
                                "Keywords (up to 5 key phrases)",
                                "Entities (people, organizations, locations)",
                                "Language (ISO 639-1 code)",
                                "Tone (formal, informal, technical, etc.)"
                            ]
                        },
                        "default": [
                            "sentiment"
                        ]
                    },
                    "apiKey": {
                        "title": "OpenAI API key",
                        "type": "string",
                        "description": "Your OpenAI API key. Required to run LLM enrichment. Keep this private."
                    },
                    "model": {
                        "title": "OpenAI model",
                        "enum": [
                            "gpt-4o-mini",
                            "gpt-4o",
                            "gpt-4-turbo"
                        ],
                        "type": "string",
                        "description": "OpenAI model to use for enrichment. gpt-4o-mini is fast and cheap; gpt-4o is more accurate.",
                        "default": "gpt-4o-mini"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
