# WhatsApp Chat Analyzer: Unanswered Chats & Response Time (`privatex/whatsapp-conversation-intelligence`) Actor

Analyze WhatsApp Business chat exports you own: response times, unanswered chats, cold leads to follow up, buying intent and repeated questions. Privacy-first: pseudonymous output, no AI API, never connects to WhatsApp or sends messages.

- **URL**: https://apify.com/privatex/whatsapp-conversation-intelligence.md
- **Developed by:** [PRIVATEX](https://apify.com/privatex) (community)
- **Categories:** Business, Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 88.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 conversation analyses

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## WhatsApp Conversation Intelligence

Find out **which customers are waiting, which leads went cold and what everybody keeps asking** – from WhatsApp Business chats that your business owns.

You export chats (or send structured messages from your CRM / Cloud API logs); the Actor returns response-time metrics, a prioritised action list and a weekly report. **It never connects to WhatsApp and never sends a message.**

### Who is it for

Small businesses and sales or support teams that handle customers on WhatsApp Business and want to see unanswered chats, slow replies and cold leads without connecting any tool to WhatsApp.

### Quick start

1. Press **Start** with the pre-ticked **Demo mode**: you get a full report on *fabricated* conversations. Every row is labelled `SYNTHETIC DEMO` and **demo runs are never charged**.
2. For your own chats: in the WhatsApp / WhatsApp Business app open a customer chat > **Export chat > Without media**. Paste the file contents into **Chat exports** as `[{"name":"customer-1","text":"<contents>"}]`.
3. Fill **Names that are YOUR side of the chat** with your business name and agent names exactly as they appear in the export (everyone else is the customer).
4. Press **Start**. Your message content is erased from the stored input immediately after it is read.

**Example input**

```json
{
  "chatExports": [{ "name": "customer-1", "text": "29/10/2025, 09:16 - Ayse: Merhaba, stokta var mi?\n29/10/2025, 09:30 - My Shop: Evet var." }],
  "businessSenders": ["My Shop"],
  "timezoneOffsetMinutes": 180
}
```

**Example output row** (SAMPLE - synthetic, illustrative values; not from a real account)

```json
{
  "priority": 5,
  "conversation": "c_3f9a1b2c4d5e",
  "flags": ["unanswered", "high_buying_intent"],
  "waitingHours": 6.5,
  "firstResponseMinutes": 14,
  "intents": ["quote_request"],
  "synthetic": false
}
```

### Pricing

**$0.01 per conversation analysed**, once per conversation (a conversation with no customer message is skipped and not billed). Re-delivery after a retry or restart never bills twice. Demo runs are free.

Pay-per-event. Platform usage (compute, storage) is included in the price - there is no separate Apify usage bill for you. A negligible Actor-start event ($0.00005 per GB of memory, minimum one) also applies. You can cap spending with Apify's "Maximum charged results / cost per run" setting; the Actor stops cleanly at your limit.

### What is verified, and what is not

- Android (12h/24h, day-first and month-first) and iOS bracket export layouts, Turkish characters and intents (quote, price, order status, complaint, availability, booking, thanks) and WhatsApp system notices are covered by automated tests using synthetic chats. Intent rules cover English, Turkish, Spanish and Portuguese.
- This Actor **never connects to a live WhatsApp account and never sends a message**. It only analyses text you give it.
- Privacy: customers appear as salted pseudonymous ids; phone numbers, names and message text are not written to the dataset (optional masked snippet is off by default). Export URLs, sender names, the pseudonym salt and all message content are removed from the run's stored INPUT before any parsing.

### Limitations

- Erasing the stored INPUT cannot remove copies you hold elsewhere (your API client, saved Tasks, schedules) - do not save chat text in a Task. If a run is interrupted after the input was erased, start a new run with your data.
- Intent and sentiment use deterministic keyword rules (EN/ES/TR/PT), not AI; unusual wording is classified as "other".
- Exports contain what is on one phone; read receipts, voice notes and media are not analysed.
- "Unanswered" means the last message is from the customer and older than your threshold; business hours are not modelled yet.
- Need real-time alerts and assignment? A separate self-hosted engine for the official WhatsApp Business Platform is available (see the repository).

Built by **PRIVATEX**. Questions or a data-format that does not parse? Open an issue on the Actor page and include the (anonymised) column headers or first lines.

### What you get

- **First-response time** – median, p90, share answered within 5 and 60 minutes, never-answered count.
- **Conversations that need action** – unanswered, 24-hour customer-service window expired, quote/price asked and then silent, high buying intent, complaints – sorted by priority.
- **Repeated customer questions** – topics asked in 3+ separate conversations (candidates for a FAQ or a quick-reply).
- **Bottlenecks** – slowest agents and slowest hours (only with 3+ conversations).
- **Weekly report** (Markdown), JSON and CSV.

All classification is deterministic (EN/ES/TR/PT keyword rules). No AI API, no per-message cost.

### Privacy by default

- Customers appear as pseudonymous ids (salted hash). Phone numbers and names are not in the output.
- Message text is **not** in the output unless you turn on `includeSnippets`, and then it is masked (emails, links, numbers).
- `scrubInputAfterRead` (default on) replaces the stored run input with a version without message content.
- Only analyse chats of customers who contacted your business, and follow your local data-protection rules. Delete the run to erase everything.

### Input

| Field | Meaning |
| --- | --- |
| `chatExports` | `[{"name":"customer-1","text":"<exported .txt>"}]` – WhatsApp > chat > Export chat > Without media. |
| `chatExportUrls` | Links to exported `.txt` files. |
| `messages` | Structured alternative: `{conversationId, direction: in/out, ts, text, agent}`. |
| `businessSenders` | Names that are *your side* of the chat (required for exports). |
| `dateOrder`, `timezoneOffsetMinutes` | Export format helpers. |
| `unansweredAfterHours`, `followUpAfterHours` | Thresholds. |
| `demoMode` | Fabricated conversations, labelled SYNTHETIC. |

Supported export layouts: Android 12h/24h, iOS `[date, time]`, day-first and month-first dates (auto-detected).

### Output

Dataset: one row per conversation (`priority`, `flags`, `waitingHours`, `firstResponseMinutes`, `intents`, `buyingIntentScore`, `serviceWindowClosesAt`, agents). Key-value store: `REPORT_MD`, `REPORT`, `conversations.csv`.

### API example

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USER~whatsapp-conversation-intelligence/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"messages":[{"conversationId":"c1","direction":"in","ts":"2026-10-28T09:00:00Z","text":"How much is shipping?"}]}'
```

# Changelog

This Actor's version history is a separate document: https://apify.com/privatex/whatsapp-conversation-intelligence/changelog.md

# Actor input Schema

## `demoMode` (type: `boolean`):

Pre-ticked so the Actor works on first click with FABRICATED conversations (every output row is labelled SYNTHETIC DEMO and is never charged). It is ignored as soon as you provide chat exports or messages, so you can leave it ticked.

## `chatExports` (type: `array`):

Each item: {"name": "customer-1", "text": "\<contents of the exported .txt>"}. In the WhatsApp app: open a chat, Export chat, Without media. Only export chats of customers who contacted your business.

## `chatExportUrls` (type: `array`):

Public or pre-signed URLs of exported .txt files (one chat per file), e.g. from your own storage.

## `messages` (type: `array`):

Alternative to exports, e.g. from your CRM or Cloud API logs. Each item: {"conversationId": "abc", "direction": "in" or "out", "ts": "2026-10-28T09:15:00Z", "text": "...", "agent": "Ann"}.

## `businessSenders` (type: `array`):

Required for text exports. Your business name and agent names exactly as they appear in the export. Everyone else is treated as the customer.

## `dateOrder` (type: `string`):

auto detects day/month order from the file. Pick explicitly if all days are 12 or lower.

## `timezoneOffsetMinutes` (type: `integer`):

Example: UTC+3 = 180, UTC-5 = -300. Exports are written in the phone's local time.

## `asOf` (type: `string`):

Reference time for waiting and follow-up calculations. Empty = now. Set it when analysing an older export.

## `unansweredAfterHours` (type: `integer`):

A conversation whose last message is from the customer and older than this is flagged.

## `followUpAfterHours` (type: `integer`):

Quote or price conversations where you replied and the customer then went quiet for this long are flagged.

## `includeSnippets` (type: `boolean`):

Off by default (privacy). When on, adds the last customer message with emails, links and numbers masked.

## `pseudonymSalt` (type: `string`):

Keeps customer pseudonyms identical across runs. Empty = random per run, so ids cannot be linked between runs.

## `scrubInputAfterRead` (type: `boolean`):

Replaces the run's stored INPUT record with a version without message content as soon as it has been read.

## Actor input object example

```json
{
  "demoMode": true,
  "chatExports": [],
  "chatExportUrls": [],
  "messages": [],
  "businessSenders": [],
  "dateOrder": "auto",
  "timezoneOffsetMinutes": 0,
  "unansweredAfterHours": 2,
  "followUpAfterHours": 24,
  "includeSnippets": false,
  "scrubInputAfterRead": true
}
```

# Actor output Schema

## `conversations` (type: `string`):

No description

## `report` (type: `string`):

No description

## `reportJson` (type: `string`):

No description

## `csv` (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 = {
    "demoMode": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("privatex/whatsapp-conversation-intelligence").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 = { "demoMode": True }

# Run the Actor and wait for it to finish
run = client.actor("privatex/whatsapp-conversation-intelligence").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 '{
  "demoMode": true
}' |
apify call privatex/whatsapp-conversation-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,privatex/whatsapp-conversation-intelligence"
        }
    }
}
```

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/BGNwbdxml4WtWTwWC/builds/BZdCIykhULcoIYThK/openapi.json