# US Brand Signal SLA Checker (`zinin/us-brand-signal-sla-checker`) Actor

Classify buyer-supplied schedule rows against an explicit UTC asOf timestamp with deterministic SLA results and bounded durations.

- **URL**: https://apify.com/zinin/us-brand-signal-sla-checker.md
- **Developed by:** [Tim Zinin](https://apify.com/zinin) (community)
- **Categories:** MCP servers, Automation, Marketing
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## US Brand Signal SLA Checker

Classify a buyer's schedule rows against an explicit UTC timestamp. This Actor is useful for agent workflows that need a small, deterministic answer to: **which items met their stated due time, which missed it, and which are still open?**

The Actor does not fetch a system clock or an external source. `asOf` is supplied by the buyer, so the same input always gives the same result. `itemId` is an opaque identifier supplied by the buyer; it is not resolved to a person, company, account, or real-world identity.

### What you send

Send `schemaVersion`, an explicit `asOf` UTC timestamp, and 1-100 rows:

```json
{
  "schemaVersion": "1.0",
  "asOf": "2026-08-05T12:00:00Z",
  "rows": [
    {"itemId": "case-001", "openedAt": "2026-08-05T08:00:00Z", "dueAt": "2026-08-05T10:00:00Z", "resolvedAt": "2026-08-05T09:30:00Z"},
    {"itemId": "case-002", "openedAt": "2026-08-05T08:00:00Z", "dueAt": "2026-08-05T09:00:00Z", "resolvedAt": null}
  ]
}
```

All timestamps must be strict `YYYY-MM-DDTHH:mm:ssZ` UTC values with real Gregorian dates. Offset timestamps, local times, fractional seconds, leap seconds, invalid dates, and non-canonical spellings are rejected. Each row must satisfy `openedAt <= dueAt`, `openedAt <= asOf`, and, when closed, `openedAt <= resolvedAt <= asOf`.

### What you get

The Dataset receives one report row. Rows and IDs are sorted by ASCII `itemId`. Each row contains:

- `classification`: `on_time`, `late`, `open_overdue`, or `open_within_sla`;
- `openedToDueSeconds`: whole seconds from opening to due time;
- `openedToResolvedSeconds`: whole seconds from opening to resolution, or opening to the supplied `asOf` for an open row;
- `overdueSeconds`: zero unless a closed row resolved after due time or an open row is evaluated at/after due time.

Boundary rules are explicit: `resolvedAt <= dueAt` is `on_time`; `resolvedAt > dueAt` is `late`; `resolvedAt == null` and `asOf >= dueAt` is `open_overdue`; `resolvedAt == null` and `asOf < dueAt` is `open_within_sla`. A row resolved exactly at its due timestamp is therefore on time, while an unresolved row at its due timestamp is overdue.

The report also returns reconciled counts, sorted IDs, and SHA-256 digests for the canonical input, classified rows, counts, and complete result. JSON Schema checks shape; runtime checks enforce temporal relationships and digest equality.

### Run it

1. Open **Try for free** in the Actor Console.
2. Paste the exact JSON shape shown in the Input section.
3. Start the run and read the one report row from the Dataset.
4. Read the truthful terminal delivery receipt from `OUTPUT`.

The runnable prefill is in `examples/input.json` and `public-task.json`. This is an inline-only Actor: it accepts no Dataset input.

### Pricing

Pay per event: **$0.005 per run start plus $0.010 per delivered result** on the FREE tier. The result event is emitted only after one confirmed Dataset write. The buyer cap must cover both charges.

| Tier | Discount | Start | Delivered result |
| --- | ---: | ---: | ---: |
| FREE | 0% | $0.00500 | $0.01000 |
| BRONZE | 5% | $0.00475 | $0.00950 |
| SILVER | 10% | $0.00450 | $0.00900 |
| GOLD | 15% | $0.00425 | $0.00850 |
| PLATINUM | 18% | $0.00410 | $0.00820 |
| DIAMOND | 20% | $0.00400 | $0.00800 |

Invalid input, insufficient cap, uncertain delivery, and an uncharged or multiply charged result are not successful results. The Actor never retries an uncertain paid Dataset push.

### Freshness, limits, and safety

- Freshness is buyer-controlled: change `asOf` or the supplied rows and run again. The Actor never reads the current clock.
- Maximum input is 100 rows; `itemId` is 1-64 characters from the restricted printable ASCII ID set `[A-Za-z0-9._:-]`.
- Input and report are bounded below 64 KiB. Oversized results fail before any paid Dataset push.
- No network, proxy, BYOK key, LLM, state, child Actor, or Dataset input is used.
- The report is an analysis of buyer-supplied schedule values, not proof that a deadline or identity is true in an external system.

### Related public Actors

These Actors can precede or follow this checker in a machine-to-machine workflow. This Actor does not call them.

| Actor | Use it for |
| --- | --- |
| [US Brand Signal Metrics Aggregator](https://apify.com/zinin/us-brand-signal-metrics-aggregator) | Aggregate signal rows before checking operational deadlines. |
| [US Brand Action Queue](https://apify.com/zinin/us-brand-action-queue) | Turn late or overdue IDs into bounded next-action rows. |
| [US Brand Signal Brief Composer](https://apify.com/zinin/us-brand-signal-brief-composer) | Summarize the resulting SLA counts for an agent or operator. |
| [US Brand Evidence Snapshot Diff](https://apify.com/zinin/us-brand-evidence-snapshot-diff) | Compare two buyer-supplied snapshots before or after a schedule review. |

### FAQ

**Does this Actor check a live CRM or current time?** No. You provide every timestamp, including `asOf`.

**What happens at the due-time boundary?** A resolved row at exactly `dueAt` is `on_time`; an unresolved row at exactly `dueAt` is `open_overdue`.

**Can I submit local time or a timezone offset?** No. Convert it to canonical UTC with `Z` before sending.

**Can I use real names?** The contract accepts opaque IDs only and does not identify people, companies, or accounts.

**What happens if delivery is uncertain?** The terminal receipt records a non-success state and the Actor does not issue a second Dataset write.

Built by [zinin](https://apify.com/zinin).

# Actor input Schema

## `schemaVersion` (type: `string`):

The only supported closed contract version.

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

Strict Gregorian UTC timestamp in YYYY-MM-DDTHH:mm:ssZ form. This value controls all open-row classification.

## `rows` (type: `array`):

One to 100 rows with opaque item IDs and explicit opened, due, and optional resolved timestamps.

## Actor input object example

```json
{
  "schemaVersion": "1.0",
  "asOf": "2026-08-05T12:00:00Z",
  "rows": [
    {
      "itemId": "case-001",
      "openedAt": "2026-08-05T08:00:00Z",
      "dueAt": "2026-08-05T10:00:00Z",
      "resolvedAt": "2026-08-05T09:30:00Z"
    },
    {
      "itemId": "case-002",
      "openedAt": "2026-08-05T08:00:00Z",
      "dueAt": "2026-08-05T09:00:00Z",
      "resolvedAt": "2026-08-05T09:30:00Z"
    },
    {
      "itemId": "case-003",
      "openedAt": "2026-08-05T08:00:00Z",
      "dueAt": "2026-08-05T09:00:00Z",
      "resolvedAt": null
    },
    {
      "itemId": "case-004",
      "openedAt": "2026-08-05T11:00:00Z",
      "dueAt": "2026-08-05T13:00:00Z",
      "resolvedAt": null
    }
  ]
}
```

# Actor output Schema

## `OUTPUT` (type: `string`):

API link to the terminal receipt when OUTPUT was stored.

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

API link to the one deterministic report row after confirmed result delivery.

# 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 = {
    "schemaVersion": "1.0",
    "asOf": "2026-08-05T12:00:00Z",
    "rows": [
        {
            "itemId": "case-001",
            "openedAt": "2026-08-05T08:00:00Z",
            "dueAt": "2026-08-05T10:00:00Z",
            "resolvedAt": "2026-08-05T09:30:00Z"
        },
        {
            "itemId": "case-002",
            "openedAt": "2026-08-05T08:00:00Z",
            "dueAt": "2026-08-05T09:00:00Z",
            "resolvedAt": "2026-08-05T09:30:00Z"
        },
        {
            "itemId": "case-003",
            "openedAt": "2026-08-05T08:00:00Z",
            "dueAt": "2026-08-05T09:00:00Z",
            "resolvedAt": null
        },
        {
            "itemId": "case-004",
            "openedAt": "2026-08-05T11:00:00Z",
            "dueAt": "2026-08-05T13:00:00Z",
            "resolvedAt": null
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zinin/us-brand-signal-sla-checker").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 = {
    "schemaVersion": "1.0",
    "asOf": "2026-08-05T12:00:00Z",
    "rows": [
        {
            "itemId": "case-001",
            "openedAt": "2026-08-05T08:00:00Z",
            "dueAt": "2026-08-05T10:00:00Z",
            "resolvedAt": "2026-08-05T09:30:00Z",
        },
        {
            "itemId": "case-002",
            "openedAt": "2026-08-05T08:00:00Z",
            "dueAt": "2026-08-05T09:00:00Z",
            "resolvedAt": "2026-08-05T09:30:00Z",
        },
        {
            "itemId": "case-003",
            "openedAt": "2026-08-05T08:00:00Z",
            "dueAt": "2026-08-05T09:00:00Z",
            "resolvedAt": None,
        },
        {
            "itemId": "case-004",
            "openedAt": "2026-08-05T11:00:00Z",
            "dueAt": "2026-08-05T13:00:00Z",
            "resolvedAt": None,
        },
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("zinin/us-brand-signal-sla-checker").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 '{
  "schemaVersion": "1.0",
  "asOf": "2026-08-05T12:00:00Z",
  "rows": [
    {
      "itemId": "case-001",
      "openedAt": "2026-08-05T08:00:00Z",
      "dueAt": "2026-08-05T10:00:00Z",
      "resolvedAt": "2026-08-05T09:30:00Z"
    },
    {
      "itemId": "case-002",
      "openedAt": "2026-08-05T08:00:00Z",
      "dueAt": "2026-08-05T09:00:00Z",
      "resolvedAt": "2026-08-05T09:30:00Z"
    },
    {
      "itemId": "case-003",
      "openedAt": "2026-08-05T08:00:00Z",
      "dueAt": "2026-08-05T09:00:00Z",
      "resolvedAt": null
    },
    {
      "itemId": "case-004",
      "openedAt": "2026-08-05T11:00:00Z",
      "dueAt": "2026-08-05T13:00:00Z",
      "resolvedAt": null
    }
  ]
}' |
apify call zinin/us-brand-signal-sla-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=zinin/us-brand-signal-sla-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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