# Angelcam Live Camera Snapshot (`angelcam/live-snapshot`) Actor

Take a live JPEG snapshot from all or selected cameras of your Angelcam account. Connect once with OAuth, then run on demand, on a schedule, or from an AI agent.

- **URL**: https://apify.com/angelcam/live-snapshot.md
- **Developed by:** [Angelcam](https://apify.com/angelcam) (community)
- **Stats:** 1 total users, 1 monthly users, 99.5% 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/actors/running/actors-in-store.md#pay-per-usage

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

## Angelcam Live Camera Snapshot

Take a **live JPEG snapshot** from all or selected cameras of your [Angelcam](https://www.angelcam.com/) account
in seconds. Connect your account once, then run it on demand, on a schedule, from your code, or from an AI agent.

**Free Actor** – there is no per-result fee. You only pay for Apify platform usage of each run, according to your Apify plan.

### 📸 What does Angelcam Live Camera Snapshot do?

It connects to your Angelcam account and, for every camera you choose:

- takes a **live snapshot** (a fresh frame, not a cached thumbnail),
- saves the JPEG to your Apify storage and gives you a **permanent link** to it,
- reports the camera's **status**, so you know when a camera is offline.

It works with your own cameras and with cameras other Angelcam users **shared with you**.

### 💡 What can you check with a snapshot and AI?

Run the Actor on a schedule and let an AI model look at each snapshot. It can answer a **yes-or-no question**,
give a **count** or a **status**, or spot a **change** from an earlier or a reference image. It works best for
things that stay true for minutes or hours, so nobody has to drive out or scroll through footage to check. For example:

- **Closing checks** – After hours, are the gates, roll-up doors and barn doors closed? Are the dumpster lids shut? Are the exterior lights on after dark? Did the store open on time?
- **Safety and compliance** – Are the fire exits, aisles and fire lanes clear? Copy the timestamped photos to your own storage to keep them as proof for inspectors and insurers.
- **Construction sites** – Have the expected materials arrived? Is the equipment back in its assigned area overnight? What changed on site since yesterday?
- **Loading docks and yards** – Which dock doors are occupied? Is the delivery lane clear? How many vehicles are on site? Is an EV charging bay blocked?
- **Property management** – Is the dumpster full, or has something been dumped next to it? Is snow blocking the entrance? Is there standing water in the garage?
- **Farms and stables** – Is the water trough empty? Are the animals at the feeder? Has the horse been lying down for several checks in a row? Is a cow or mare in the birthing pen showing signs of labor?
- **Equipment rooms** – Is the gauge needle within its marked range? Is a machine warning light on? Is the greenhouse vent open?
- **Retail** – Is a shelf empty? Is the promotional display set up as agreed?
- **Camera health** – Is each camera still showing what it should, or is the lens blocked, dirty or knocked out of position?

A snapshot every few minutes does not replace an alarm system or real-time video analytics. Use it for checks, not for catching events as they happen.

The Actor takes the snapshots; the AI check runs in your agent or workflow. Ask an [AI agent over MCP](#mcp-claude-cursor-chatgpt-and-other-mcp-clients),
or send `imageUrl` to an AI step in Make, n8n or Zapier. Set `maxWidth` to send smaller images to the model.

### 💰 How much does the AI check cost?

The AI check is billed by your AI model provider, separately from Apify. We tested one question, *"Is the gate open?"*,
on the same night-time snapshot of a shop entrance with several models and settings. All of them correctly answered
that the gate was open. Monthly cost assumes 30 days and covers only the AI model, not Apify platform usage of the runs:

| Model and image size | Per check | Every 5 min (8,640 checks) | Every 30 min (1,440) | Every hour (720) | Model's confidence |
|---|---|---|---|---|---|
| Claude Opus 5.5, 1920×1080 | $0.01366 | $117.99 | $19.66 | $9.83 | 0.85 |
| Claude Opus 5.5, 1024×576 | $0.00608 | $52.53 | $8.76 | $4.38 | 0.85 |
| Claude Opus 5.5, 512×288 | $0.00371 | $32.04 | $5.34 | $2.67 | 0.80 |
| gpt-6-luna, detail `low` | $0.000073 | $0.63 | $0.10 | $0.05 | 0.91 |
| gpt-6-luna, detail `high` | $0.000297 | $2.57 | $0.43 | $0.21 | 0.96 |

- A smaller or cheaper model is usually enough for simple yes-or-no checks. On this test, gpt-6-luna cost about 12 to 50 times less per check than Claude Opus 5.5 with the smallest image.
- Claude Opus 5.5 has no low or high detail setting, so the way to lower its cost is to send a smaller image with `maxWidth`.
- Checking less often cuts the cost the most. Pick the longest interval that still catches the problem in time.

*Tested on 23 September 2026. The prices are for these models at that date and will change. Check your provider's current pricing.*

### 🗂️ What data do you get?

| Field | Example | Description |
|---|---|---|
| `cameraId` | `12345` | Angelcam camera ID |
| `cameraName` | `Paddock North` | Camera name in MyAngelcam |
| `source` | `owned` | `owned` (your camera) or `shared` (shared with you) |
| `status` | `online` | `online` (snapshot taken), `offline` or `error` |
| `snapshotTakenAt` | `2026-09-23T14:32:05Z` | When the snapshot was taken (UTC) |
| `imageUrl` | `https://api.apify.com/v2/key-value-stores/…/camera-12345.jpg` | Link to the JPEG |
| `error` | `null` | Why no snapshot was taken, if so |

### 🚀 How to take a snapshot of your cameras

1. **Create a free [Apify account](https://console.apify.com/sign-up)** if you don't have one.
2. **Connect Angelcam**: open **[my.angelcam.com/connect/apify](https://my.angelcam.com/connect/apify/?utm_source=apify\&utm_medium=store\&utm_campaign=live-snapshot-actor\&utm_content=setup-step)**, click
   **Create an account and connect** (or **Sign in and connect** if you already use Angelcam) and allow access.
3. **Copy the connection token** shown on the page.
4. **Open this Actor**, paste the token into *Angelcam connection token* and click **Start**.
5. **Get your snapshots** in the *Output* tab, or download them as JSON, CSV or Excel.

Want a new snapshot regularly? Add an Apify **Schedule** to the Actor, for example every 2 minutes.

No cameras in your Angelcam account yet? See [the FAQ](#dont-have-a-camera-connected-to-angelcam-yet).

### ⬇️ Input

Only the connection token is required.

| Field | Required | Description |
|---|---|---|
| `refreshToken` | yes | Connection token from [my.angelcam.com/connect/apify](https://my.angelcam.com/connect/apify/?utm_source=apify\&utm_medium=store\&utm_campaign=live-snapshot-actor\&utm_content=input-table). Kept secret by Apify. |
| `cameraIds` | no | Camera IDs to take a snapshot from. Leave empty for **all** cameras, including cameras shared with you. |
| `maxWidth` | no | Downscale snapshots to at most this width in pixels, e.g. to send smaller images to an AI model. Leave empty for the original resolution. |

```json
{
    "refreshToken": "your-connection-token",
    "cameraIds": ["12345", "67890"],
    "maxWidth": 1280
}
```

### ⬆️ Output

One dataset item per camera. In the Apify Console you see a table with a thumbnail of each snapshot.

```json
[
    {
        "cameraId": "12345",
        "cameraName": "Paddock North",
        "source": "owned",
        "status": "online",
        "snapshotTakenAt": "2026-09-23T14:32:05Z",
        "imageUrl": "https://api.apify.com/v2/key-value-stores/<store-id>/records/camera-12345.jpg",
        "error": null
    },
    {
        "cameraId": "67890",
        "cameraName": "Barn",
        "source": "shared",
        "status": "offline",
        "snapshotTakenAt": null,
        "imageUrl": null,
        "error": "Camera is offline"
    }
]
```

- Offline cameras and camera IDs that are not found are **still reported**, so an automation can tell
  "camera offline" apart from "no data".
- Items are saved as soon as each camera is done, so their order can differ from `cameraIds`.
- The run's status message summarizes the result, e.g. *"4 of 5 snapshots taken · 1 camera offline"*.

### 🤖 Use it from AI agents and your code

#### MCP (Claude, Cursor, ChatGPT and other MCP clients)

Add the [Apify MCP server](https://docs.apify.com/integrations/mcp) with this Actor as a tool:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=angelcam_shared/angelcam-live-snapshot"
        }
    }
}
```

Then ask, for example: *"Take a snapshot of my Paddock camera and tell me if the horse is lying down."*
The agent needs your connection token as the `refreshToken` input. Getting it requires signing in to Angelcam
in a browser, so a person has to do step 2 above once.

#### API

Run the Actor and get the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/angelcam_shared~angelcam-live-snapshot/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"refreshToken": "<ANGELCAM_CONNECTION_TOKEN>"}'
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('<APIFY_TOKEN>')
run = client.actor('angelcam_shared/angelcam-live-snapshot').call(
    run_input={'refreshToken': '<ANGELCAM_CONNECTION_TOKEN>'}
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item['cameraName'], item['status'], item['imageUrl'])
```

#### JavaScript

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

const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('angelcam_shared/angelcam-live-snapshot').call({ refreshToken: '<ANGELCAM_CONNECTION_TOKEN>' });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => console.log(item.cameraName, item.status, item.imageUrl));
```

You can also connect the Actor to Zapier, Make, n8n, Slack, Google Drive and more with
[Apify integrations](https://docs.apify.com/platform/integrations), for example to send each snapshot to a chat.

### ❓ FAQ

#### How much does it cost?

The Actor itself is free. Each run uses a small amount of Apify platform resources, billed according to your Apify plan.
If you check the snapshots with an AI model, your model provider bills that separately. See
*How much does the AI check cost?* above.

#### Does it record video?

No. Each run takes one still image per camera at that moment. For continuous recording, use Angelcam's
cloud recording in MyAngelcam.

#### How often can I take snapshots?

As often as you schedule the Actor, e.g. every few minutes with an Apify Schedule. Each run takes only a few
seconds and reuses its Angelcam access between runs.

#### What can the Actor access in my Angelcam account?

The Actor only lists your cameras and takes snapshots. The connection **keeps working as long as the Actor uses it**
(e.g. on a schedule) and expires after **30 days without use**; then connect again and update the input. You can revoke it anytime in MyAngelcam → My account → Application Access.

#### Where are my snapshots stored?

In your own Apify account, in the storage of each run. Apify keeps them according to your plan's data
retention. To keep them longer, copy them with an integration (e.g. a webhook, S3 or Google Drive).

#### Which cameras does it work with?

Any camera connected to your Angelcam account, including cameras shared with you by other Angelcam users.

#### Don't have a camera connected to Angelcam yet?

Try the Angelcam demo account, or check whether your own camera works with Angelcam in
[MyAngelcam](https://my.angelcam.com/?utm_source=apify\&utm_medium=store\&utm_campaign=live-snapshot-actor\&utm_content=no-camera).

#### Why did my run fail?

| Status message | What to do |
|---|---|
| *Your Angelcam connection expired or was revoked* | The token was not used for 30 days or was revoked. Connect again and update the input. |
| *Input field "refreshToken" is required* | Paste the connection token from the Connect page. |
| *Could not reach the Angelcam API* | A temporary problem. The next run will try again. |

A camera that is offline does **not** fail the run: it is reported with `status: "offline"`.

#### I found a bug or have an idea

Please open an issue in the Actor's **Issues** tab. See the [changelog](CHANGELOG.md) for what changed in each version.

# Changelog

This Actor's version history is a separate document: https://apify.com/angelcam/live-snapshot/changelog.md

# Actor input Schema

## `refreshToken` (type: `string`):

Token that lets the Actor access your Angelcam cameras. Get it in one click at <a href='https://my.angelcam.com/connect/apify/?utm_source=apify&utm_medium=console&utm_campaign=live-snapshot-actor&utm_content=input-field' target='_blank'>my.angelcam.com/connect/apify</a>. It keeps working while the Actor uses it, expires after 30 days without use, and you can revoke it anytime in MyAngelcam → My account → Application Access.

## `cameraIds` (type: `array`):

IDs of the cameras to take a snapshot from. Leave empty to take a snapshot from all cameras in your account, including cameras shared with you.

## `maxWidth` (type: `integer`):

Downscale snapshots to at most this width in pixels (aspect ratio is kept). Useful to send smaller images to an AI model. Leave empty for the camera's original resolution.

## Actor input object example

```json
{
  "cameraIds": []
}
```

# Actor output Schema

## `snapshots` (type: `string`):

One item per camera with its status and the imageUrl of the JPEG snapshot.

## `images` (type: `string`):

The JPEG snapshots, one per online camera (camera-<id>.jpg).

# 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 = {
    "cameraIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("angelcam/live-snapshot").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 = { "cameraIds": [] }

# Run the Actor and wait for it to finish
run = client.actor("angelcam/live-snapshot").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 '{
  "cameraIds": []
}' |
apify call angelcam/live-snapshot --silent --output-dataset

```

## MCP server setup

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

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/3oMxd8whrThp9X553/builds/BGH2kmIMGkQk2AxzB/openapi.json