# UpScrolled Monitor - Public Profiles and Post Changes (`maydit/upscrolled-public-watchlist`) Actor

Track public UpScrolled profiles and exact post URLs. Export creator counters, captions, source engagement counts and saved changes. No login, API key or media downloads.

- **URL**: https://apify.com/maydit/upscrolled-public-watchlist.md
- **Developed by:** [Brandt May](https://apify.com/maydit) (community)
- **Categories:** Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 public profile or post observations

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

![Follow public profiles and posts — illustrative workflow](https://api.apify.com/v2/key-value-stores/YGxD9JRpduom8Q5Zd/records/upscrolled-public-watchlist-f1a2e09b6819.png?signature=1zh8LEzKoTcR5M40I3qdZ)

[Open this Actor in Console](https://console.apify.com/actors/zvH4xJGebUSWZ59JY/input) · [Try a small run](#try-a-small-run) · [Cost](#cost)

**Mayd-It · Creator watchlists**

Keep a focused record of public UpScrolled profiles and posts you already know. Collect bios, captions and published counters, then compare them with your own saved observations.

**Source scope:** Exact public profile and post pages. No login or API key; no follower lists or complete post-history discovery.

### What you get

- Profile observations with follower, following and post counters.
- Known post captions and the engagement counters shown in public page data.
- Saved comparisons with changed fields and previous values.

### Try a small run

Copy this exact input into the Actor’s JSON input editor, then run it.

```json
{
  "profiles": [
    "UpScrolled",
    "Support"
  ],
  "maxResults": 10
}
```

This example requests the official `UpScrolled` and `Support` profiles. Run it, then open the dataset for observations and the `SUMMARY` record for coverage. `{}` or two empty target lists uses the same profiles. For a post-only run, supply `postUrls` and keep `profiles` empty.

### Understand your run

Open **Run report** in the run’s Output tab for saved-record counts, reported source issues and limits, and suggested next steps. Use **CSV export** to take the saved results into a spreadsheet. The existing JSON results and detailed machine-readable summary remain available.

The report reflects this run’s recorded coverage. A successful run or a saved result does not establish that every possible source record was collected.

### Cost

**FREE / BRONZE: $0.003 per saved observation ($3 per 1,000).** SILVER: $2.40 per 1,000. GOLD / PLATINUM / DIAMOND: $1.80 per 1,000.

The Actor Start event is **$0.00005 per charged start unit**, with one unit per GB of Actor memory and a minimum of one. The Pricing tab shows the rate for your Apify tier. New, changed and ordinarily saved unchanged observations use the same result rate. Skipped unchanged rows, rejected events, duplicates and error diagnostics are not paid result rows. Use `onlyChanges` for repeated monitoring after establishing history. Spending allowance is checked before each dataset write.

### A real result

Selected fields from a recorded run on **10 October 2026**. This is an example of the output shape; source content and counters can change.

```json
{
  "recordType": "profile",
  "handle": "UpScrolled",
  "followers": 185962,
  "following": 2,
  "posts": 220,
  "comparisonStatus": "not_requested",
  "observedAt": "2026-10-10T23:01:40.408Z"
}
```

These are public source counters at the recorded observation time, not reach or unique-person measurements.

### More examples

#### UpScrolled - Public Milestone Post Observation

Observe this exact public milestone post without adding profile targets.

```json
{
  "profiles": [],
  "postUrls": [
    "https://upscrolled.com/@UpScrolled/4ca966c0-ff8c-11f0-8080-80004f5375c5"
  ],
  "maxResults": 5
}
```

#### UpScrolled - Saved Public Profile Comparison

Establish a saved comparison for the official profile. Repeat with `onlyChanges: true` to skip unchanged observations. Configure an Apify schedule separately if needed.

```json
{
  "profiles": [
    "UpScrolled"
  ],
  "comparePrevious": true,
  "snapshotName": "upscrolled-example",
  "maxResults": 5
}
```

***

### Input reference

| Field | Meaning |
| --- | --- |
| `profiles` | Up to 50 handles or exact `https://upscrolled.com/@handle` URLs. |
| `postUrls` | Up to 50 exact public `/@handle/post-uuid` URLs. |
| `keywords` | Optional case-insensitive OR substrings in handle, name and bio/caption. Includes field and excerpt evidence. |
| `maxResults` | Saved-row cap, default 20. At most 100 requested targets can be inspected. |
| `comparePrevious` | Save and compare confirmed observations. Default false. |
| `onlyChanges` | Enable comparison and suppress unchanged observations. Default false. |
| `snapshotName` | History namespace; 1–80 letters, digits, underscores or hyphens. Default `default`. |
| `maxRunSeconds` | Request and output time budget, default 240 seconds. |

### Output reference

One row is one profile or post observation. `id` combines record type with the platform's public UUID; `recordType` distinguishes `profile` from `post`. Shared fields include `url`, `handle`, `displayName`, `profileId`, `isVerified`, `text`, `observedAt`, `source`, `matchedTerms` and `matchEvidence`.

Profile rows contain `followers`, `following`, `posts` and public `externalLinks`. Their `text` is the bio. Post rows contain `postId`, `postType`, `publishedAt`, `sourceUpdatedAt`, `likes`, `sourceCommentCount`, `reposts`, `textHash` and the caption in `text`. Caption output is capped at 20,000 characters with `textTruncated`; comparison hashes cover the full supplied caption. Fields that do not apply to a row type are null.

Post metrics are the counters embedded in the public page. `sourceCommentCount` can differ from visible comments because the site may filter, moderate or aggregate them differently. Counters are observations, not unique people, verified reach, or historical time series. `sourceUpdatedAt` is the object's source timestamp and does not prove a caption edit. Media files and comment bodies are not fetched.

### Saved comparisons

`comparisonStatus` is `not_requested`, `new`, `changed` or `unchanged`. `changedFields`, `previous` and `previousObservedAt` record differences from confirmed prior output. Counter changes and bio/caption changes are observed; the Actor does not infer their causes. The first comparison run establishes a baseline and returns rows. A later unchanged run with `onlyChanges` can return zero rows.

History lives in the named `maydit-upscrolled-watchlist-history` store and is scoped by namespace, requested targets and filters. Changing the result cap does not reset it. Only successfully saved rows advance history. Missing, private, unavailable or omitted targets never establish deletion. Invalid stored history is rejected, and scopes are limited to 20,000 identities. Run one writer per scope: a read-back conflict check detects some concurrent writes but is not a transactional lock.

### Coverage and failures

This covers exact publicly accessible pages only. Private profiles and source-marked sensitive posts are skipped. It cannot recover deleted posts, private messages, signed-in feeds or a complete archive. It uses public page data formats that UpScrolled may change. [UpScrolled says it does not currently provide a public API](https://support.upscrolled.com/en/articles/15119428-does-upscrolled-have-a-public-api).

The `SUMMARY` record reports successful pages, skipped private/sensitive records, duplicates, filters, failures, limits and targets not reached. A source failure is never a paid error row. If every source fails, the run fails clearly. Mixed source failures produce partial output and a partial summary. The Actor respects robots rules and bounds requests, response sizes, retries and redirects within its deadline.

### Troubleshooting and support

| If you see… | Check this |
| --- | --- |
| No row for a requested target | Inspect `SUMMARY` for private or source-marked sensitive content, filters, a missing page, or a source failure. |
| A counter differs from the visible interface | The row preserves the public page counter. `sourceCommentCount` can include differently filtered or aggregated comments. |
| An unchanged repeat has no rows | With `onlyChanges`, zero saved rows can be the expected result. Check coverage and failure fields before treating it as a successful check. |

For help, open an Actor issue or contact **bmay@mayd-it.com**. Include the run ID, selected sources and the relevant `SUMMARY` message. Do not send credentials. This Actor is independent of the platform.

Public source information remains available on UpScrolled. The fee covers structured collection and saved comparisons. This Actor is independent of and is not endorsed by UpScrolled.

# Actor input Schema

## `profiles` (type: `array`):

Up to 50 handles (e.g. UpScrolled) or exact https://upscrolled.com/@handle URLs. No private profiles. If both target lists are empty, observe official UpScrolled and Support profiles.

## `postUrls` (type: `array`):

Up to 50 exact https://upscrolled.com/@handle/post-uuid URLs. This Actor reads requested pages, not profile timelines or global search.

## `keywords` (type: `array`):

Up to 30 case-insensitive OR substrings in handle, display name and public bio/caption. Match evidence is included. Empty includes every supplied valid public target.

## `maxResults` (type: `integer`):

Cap saved profile/post observations, up to 1000; there are at most 100 requested targets. Unchanged skipped observations do not consume the saved-row cap.

## `comparePrevious` (type: `boolean`):

Save confirmed observations in named history; repeated runs can detect counter, bio or caption changes. First run establishes a baseline. Use one writer per snapshot scope.

## `onlyChanges` (type: `boolean`):

Enable comparison and skip unchanged observations. A repeat can legitimately return no rows; the first run returns its baseline.

## `snapshotName` (type: `string`):

1–80 letters, digits, underscores or hyphens. Use a new name to reset history. Different filters create different scopes. Only confirmed saved rows advance history.

## `maxRunSeconds` (type: `integer`):

Own wall-clock budget, also capped by the platform deadline minus 25 seconds. Source requests, retries, output and history obey the budget.

## Actor input object example

```json
{
  "profiles": [
    "UpScrolled",
    "Support"
  ],
  "postUrls": [],
  "keywords": [],
  "maxResults": 20,
  "comparePrevious": false,
  "onlyChanges": false,
  "snapshotName": "default",
  "maxRunSeconds": 240
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `runReport` (type: `string`):

Readable summary of saved records, reported source coverage, limits and next steps. Available when this run saves its SUMMARY.

## `csvExport` (type: `string`):

Download saved dataset records as a CSV file for spreadsheets and other tools.

## `summary` (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 = {
    "profiles": [
        "UpScrolled",
        "Support"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("maydit/upscrolled-public-watchlist").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 = {
    "profiles": [
        "UpScrolled",
        "Support",
    ],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("maydit/upscrolled-public-watchlist").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 '{
  "profiles": [
    "UpScrolled",
    "Support"
  ],
  "maxResults": 20
}' |
apify call maydit/upscrolled-public-watchlist --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,maydit/upscrolled-public-watchlist"
        }
    }
}
```

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/zvH4xJGebUSWZ59JY/builds/rdyKl6xDk5JvqBdLF/openapi.json