Api Endpoint Monitor

Pricing

from $1.00 / 1,000 results

Api Endpoint Monitor

Never get surprised by API changes again. This Actor continuously monitors your public APIs, tracks endpoint changes, auto-generates OpenAPI documentation, and alerts you instantly when breaking changes occur.

Pricing

from $1.00 / 1,000 results

Rating

0.0

(0)

Developer

Dev with Bobby

Maintained by Community

Actor stats

Bookmarked

Total users

Monthly active users

2 days ago

Last modified

AGENTS.md

1## What are Apify Actors?
2
3- Actors are serverless cloud programs that can perform anything from a simple action, like filling out a web form, to a complex operation, like crawling an entire website or removing duplicates from a large dataset.
4- Actors are programs packaged as Docker images, which accept a well-defined JSON input, perform an action, and optionally produce a well-defined JSON output.
5
6### Apify Actor directory structure
7
8```text
9.actor/
10├── actor.json # Actor config: name, version, env vars, runtime settings
11├── input_schema.json # Input validation & Console form definition
12├── dataset_schema.json # Dataset schema definition
13└── output_schema.json # Specifies where an Actor stores its output
14src/
15└── main.js # Actor entry point and orchestrator
16storage/ # Local storage (mirrors Cloud during development)
17├── datasets/ # Output items (JSON objects)
18├── key_value_stores/ # Files, config, INPUT
19└── request_queues/ # Pending crawl requests
20Dockerfile # Container image definition
21AGENTS.md # AI agent instructions (this file)
22```
23
24## Apify CLI
25
26### Installation
27
28- Install Apify CLI only if it is not already installed.
29- If Apify CLI is not installed, install it using the following commands:
30  - macOS/Linux: `curl -fsSL https://apify.com/install-cli.sh | bash`
31  - Windows: `irm https://apify.com/install-cli.ps1 | iex`
32
33### Apify CLI Commands
34
35```bash
36# Local development
37apify run                              # Run Actor locally
38
39# Authentication & deployment
40apify login                            # Authenticate account
41apify push                             # Deploy to Apify platform
42
43# Help
44apify help                             # List all commands
45```
46
47## Do
48
49- use the default values for all fields in the actor.json, input_schema.json, output_schema.json, and main.js files
50- use Apify CLI to run the Actor locally, and push it to the Apify platform
51- accept well-defined JSON input and produce structured JSON output
52- use Apify SDK (`apify`) for code running ON Apify platform
53- validate input early with proper error handling and fail gracefully
54- use CheerioCrawler for static HTML content (10x faster than browsers)
55- use PlaywrightCrawler only for JavaScript-heavy sites and dynamic content
56- use router pattern (createCheerioRouter/createPlaywrightRouter) for complex crawls
57- implement retry strategies with exponential backoff for failed requests
58- use proper concurrency settings (HTTP: 10-50, Browser: 1-5)
59- set sensible defaults in `.actor/input_schema.json` for all optional fields
60- set up output schema in `.actor/output_schema.json`
61- clean and validate data before pushing to dataset
62- use semantic CSS selectors and fallback strategies for missing elements
63- respect robots.txt, ToS, and implement rate limiting with delays
64- check which tools (cheerio/playwright/crawlee) are installed before applying guidance
65
66## Don't
67
68- do not run apify create command
69- do not rely on `Dataset.getInfo()` for final counts on Cloud platform
70- do not use browser crawlers when HTTP/Cheerio works (massive performance gains with HTTP)
71- do not hard code values that should be in input schema or environment variables
72- do not skip input validation or error handling
73- do not overload servers - use appropriate concurrency and delays
74- do not scrape prohibited content or ignore Terms of Service
75- do not store personal/sensitive data unless explicitly permitted
76- do not use deprecated options like `requestHandlerTimeoutMillis` on CheerioCrawler (v3.x)
77- do not use `additionalHttpHeaders` - use `preNavigationHooks` instead
78
79## Actor Input Schema
80
81The input schema defines the input parameters for an Actor. It's a JSON object comprising various field types supported by the Apify platform.
82
83### Structure
84
85```json
86{
87    "title": "<INPUT-SCHEMA-TITLE>",
88    "type": "object",
89    "schemaVersion": 1,
90    "properties": {
91        /* define input fields here */
92    },
93    "required": []
94}
95```
96
97## Actor Output Schema
98
99The Actor output schema builds upon the schemas for the dataset and key-value store. It specifies where an Actor stores its output and defines templates for accessing that output. Apify Console uses these output definitions to display run results.
100
101### Structure
102
103```json
104{
105    "actorOutputSchemaVersion": 1,
106    "title": "<OUTPUT-SCHEMA-TITLE>",
107    "properties": {
108        /* define your outputs here */
109    }
110}
111```
112
113### Output Schema Template Variables
114
115- `links` (object) - Contains quick links to most commonly used URLs
116- `links.publicRunUrl` (string) - Public run url in format `https://console.apify.com/view/runs/:runId`
117- `links.consoleRunUrl` (string) - Console run url in format `https://console.apify.com/actors/runs/:runId`
118- `links.apiRunUrl` (string) - API run url in format `https://api.apify.com/v2/actor-runs/:runId`
119- `links.apiDefaultDatasetUrl` (string) - API url of default dataset in format `https://api.apify.com/v2/datasets/:defaultDatasetId`
120- `links.apiDefaultKeyValueStoreUrl` (string) - API url of default key-value store in format `https://api.apify.com/v2/key-value-stores/:defaultKeyValueStoreId`
121- `links.containerRunUrl` (string) - URL of a webserver running inside the run in format `https://<containerId>.runs.apify.net/`
122- `run` (object) - Contains information about the run same as it is returned from the `GET Run` API endpoint
123- `run.defaultDatasetId` (string) - ID of the default dataset
124- `run.defaultKeyValueStoreId` (string) - ID of the default key-value store
125
126## Dataset Schema Specification
127
128The dataset schema defines how your Actor's output data is structured, transformed, and displayed in the Output tab in the Apify Console.
129
130### Structure
131
132```json
133{
134    "actorSpecification": 1,
135    "fields": {},
136    "views": {
137        "<VIEW_NAME>": {
138            "title": "string (required)",
139            "description": "string (optional)",
140            "transformation": {
141                "fields": ["string (required)"],
142                "unwind": ["string (optional)"],
143                "flatten": ["string (optional)"],
144                "omit": ["string (optional)"],
145                "limit": "integer (optional)",
146                "desc": "boolean (optional)"
147            },
148            "display": {
149                "component": "table (required)",
150                "properties": {
151                    "<FIELD_NAME>": {
152                        "label": "string (optional)",
153                        "format": "text|number|date|link|boolean|image|array|object (optional)"
154                    }
155                }
156            }
157        }
158    }
159}
160```
161
162**Dataset Schema Properties:**
163
164- `actorSpecification` (integer, required) - Specifies the version of dataset schema structure document (currently only version 1)
165- `fields` (JSONSchema object, required) - Schema of one dataset object (use JsonSchema Draft 2020-12 or compatible)
166- `views` (DatasetView object, required) - Object with API and UI views description
167
168**DatasetView Properties:**
169
170- `title` (string, required) - Visible in UI Output tab and API
171- `description` (string, optional) - Only available in API response
172- `transformation` (ViewTransformation object, required) - Data transformation applied when loading from Dataset API
173- `display` (ViewDisplay object, required) - Output tab UI visualization definition
174
175**ViewTransformation Properties:**
176
177- `fields` (string[], required) - Fields to present in output (order matches column order)
178- `unwind` (string[], optional) - Deconstructs nested children into parent object
179- `flatten` (string[], optional) - Transforms nested object into flat structure
180- `omit` (string[], optional) - Removes specified fields from output
181- `limit` (integer, optional) - Maximum number of results (default: all)
182- `desc` (boolean, optional) - Sort order (true = newest first)
183
184**ViewDisplay Properties:**
185
186- `component` (string, required) - Only `table` is available
187- `properties` (Object, optional) - Keys matching `transformation.fields` with ViewDisplayProperty values
188
189**ViewDisplayProperty Properties:**
190
191- `label` (string, optional) - Table column header
192- `format` (string, optional) - One of: `text`, `number`, `date`, `link`, `boolean`, `image`, `array`, `object`
193
194## Key-Value Store Schema Specification
195
196The key-value store schema organizes keys into logical groups called collections for easier data management.
197
198### Structure
199
200```json
201{
202    "actorKeyValueStoreSchemaVersion": 1,
203    "title": "string (required)",
204    "description": "string (optional)",
205    "collections": {
206        "<COLLECTION_NAME>": {
207            "title": "string (required)",
208            "description": "string (optional)",
209            "key": "string (conditional - use key OR keyPrefix)",
210            "keyPrefix": "string (conditional - use key OR keyPrefix)",
211            "contentTypes": ["string (optional)"],
212            "jsonSchema": "object (optional)"
213        }
214    }
215}
216```
217
218**Key-Value Store Schema Properties:**
219
220- `actorKeyValueStoreSchemaVersion` (integer, required) - Version of key-value store schema structure document (currently only version 1)
221- `title` (string, required) - Title of the schema
222- `description` (string, optional) - Description of the schema
223- `collections` (Object, required) - Object where each key is a collection ID and value is a Collection object
224
225**Collection Properties:**
226
227- `title` (string, required) - Collection title shown in UI tabs
228- `description` (string, optional) - Description appearing in UI tooltips
229- `key` (string, conditional) - Single specific key for this collection
230- `keyPrefix` (string, conditional) - Prefix for keys included in this collection
231- `contentTypes` (string[], optional) - Allowed content types for validation
232- `jsonSchema` (object, optional) - JSON Schema Draft 07 format for `application/json` content type validation
233
234Either `key` or `keyPrefix` must be specified for each collection, but not both.
235
236## Apify MCP Tools
237
238If MCP server is configured, use these tools for documentation:
239
240- `search-apify-docs` - Search documentation
241- `fetch-apify-docs` - Get full doc pages
242
243Otherwise, reference: `@https://mcp.apify.com/`
244
245## Resources
246
247- [docs.apify.com/llms.txt](https://docs.apify.com/llms.txt) - Quick reference
248- [docs.apify.com/llms-full.txt](https://docs.apify.com/llms-full.txt) - Complete docs
249- [crawlee.dev](https://crawlee.dev) - Crawlee documentation
250- [whitepaper.actor](https://raw.githubusercontent.com/apify/actor-whitepaper/refs/heads/master/README.md) - Complete Actor specification

Dockerfile

# Specify the base Docker image. You can read more about
# the available images at https://docs.apify.com/sdk/js/docs/guides/docker-images
# You can also use any other image from Docker Hub.
FROM apify/actor-node:22

# Check preinstalled packages
RUN npm ls crawlee apify puppeteer playwright

# Copy just package.json and package-lock.json
# to speed up the build using Docker layer cache.
COPY --chown=myuser:myuser package*.json ./

# Install NPM packages, skip optional and development dependencies to
# keep the image small. Avoid logging too much and print the dependency
# tree for debugging
RUN npm --quiet set progress=false     && npm install --omit=dev --omit=optional     && echo "Installed NPM packages:"     && (npm list --omit=dev --all || true)     && echo "Node.js version:"     && node --version     && echo "NPM version:"     && npm --version     && rm -r ~/.npm

# Next, copy the remaining files and directories with the source code.
# Since we do this after NPM install, quick build will be really fast
# for most source file changes.
COPY --chown=myuser:myuser . ./

# Run the image.
CMD npm start --silent

package.json

{
    "name": "api-endpoint-monitor",
    "version": "0.0.1",
    "type": "module",
    "description": "Monitors public APIs, tracks changes to endpoints, generates/updates documentation, and alerts users to breaking changes.",
    "engines": {
        "node": ">=20.0.0"
    },
    "dependencies": {
        "apify": "^3.4.2",
        "crawlee": "^3.13.8"
    },
    "devDependencies": {
        "@apify/eslint-config": "^1.0.0",
        "eslint": "^9.29.0",
        "eslint-config-prettier": "^10.1.5",
        "prettier": "^3.5.3"
    },
    "scripts": {
        "start": "node src/main.js",
        "format": "prettier --write .",
        "format:check": "prettier --check .",
        "lint": "eslint",
        "lint:fix": "eslint --fix",
        "test": "echo 'Error: oops, the Actor has no tests yet, sad!' && exit 1"
    },
    "author": "It's not you it's me",
    "license": "ISC"
}

.actor/actor.json

{
    "actorSpecification": 1,
    "name": "api-endpoint-monitor",
    "title": "API Endpoint Monitor & Documentation Generator",
    "description": "Monitors public APIs, tracks changes to endpoints, generates/updates documentation, and alerts users to breaking changes.",
    "version": "0.0",
    "meta": {
        "templateId": "ai-generated-actor",
        "generatedBy": "claude-sonnet-4-20250514"
    },
    "input": "./input_schema.json",
    "output": "./output_schema.json",
    "storages": {
        "dataset": "./dataset_schema.json"
    },
    "dockerfile": "../Dockerfile"
}

.actor/dataset_schema.json

{
    "actorSpecification": 1,
    "fields": {},
    "views": {
        "overview": {
            "title": "API Monitoring Overview",
            "transformation": {
                "fields": ["endpoint", "status", "responseTime", "schemaValid", "changesDetected", "timestamp"]
            },
            "display": {
                "component": "table",
                "properties": {
                    "endpoint": {
                        "label": "Endpoint URL",
                        "format": "link"
                    },
                    "status": {
                        "label": "HTTP Status",
                        "format": "number"
                    },
                    "responseTime": {
                        "label": "Response Time (ms)",
                        "format": "number"
                    },
                    "schemaValid": {
                        "label": "Schema Valid",
                        "format": "boolean"
                    },
                    "changesDetected": {
                        "label": "Changes Detected",
                        "format": "boolean"
                    },
                    "timestamp": {
                        "label": "Checked At",
                        "format": "date"
                    }
                }
            }
        },
        "detailed": {
            "title": "Detailed Results",
            "transformation": {
                "fields": ["endpoint", "status", "responseTime", "responseHeaders", "schemaChanges", "generatedDocs", "error", "timestamp"]
            },
            "display": {
                "component": "table",
                "properties": {
                    "endpoint": {
                        "label": "Endpoint URL",
                        "format": "link"
                    },
                    "status": {
                        "label": "HTTP Status",
                        "format": "number"
                    },
                    "responseTime": {
                        "label": "Response Time (ms)",
                        "format": "number"
                    },
                    "responseHeaders": {
                        "label": "Response Headers",
                        "format": "object"
                    },
                    "schemaChanges": {
                        "label": "Schema Changes",
                        "format": "array"
                    },
                    "generatedDocs": {
                        "label": "Generated Docs",
                        "format": "object"
                    },
                    "error": {
                        "label": "Error",
                        "format": "text"
                    },
                    "timestamp": {
                        "label": "Checked At",
                        "format": "date"
                    }
                }
            }
        }
    }
}

.actor/input_schema.json

{
    "title": "Input schema for API Endpoint Monitor",
    "type": "object",
    "schemaVersion": 1,
    "properties": {
        "apiEndpoints": {
            "title": "API Endpoints",
            "type": "array",
            "description": "List of API endpoint URLs to monitor. Each endpoint will be called and analyzed.",
            "editor": "stringList",
            "prefill": [
                "https://jsonplaceholder.typicode.com/posts",
                "https://jsonplaceholder.typicode.com/users"
            ]
        },
        "httpMethod": {
            "title": "HTTP Method",
            "type": "string",
            "description": "HTTP method to use when calling the API endpoints.",
            "editor": "select",
            "enum": ["GET", "POST", "PUT", "PATCH", "DELETE"],
            "default": "GET"
        },
        "authHeaders": {
            "title": "Authentication Headers",
            "type": "object",
            "description": "Optional authentication headers to include in API requests (e.g., {\"Authorization\": \"Bearer token\"}).",
            "editor": "json",
            "prefill": {}
        },
        "requestBody": {
            "title": "Request Body",
            "type": "object",
            "description": "Optional request body for POST/PUT/PATCH requests.",
            "editor": "json",
            "prefill": {}
        },
        "expectedSchema": {
            "title": "Expected Schema",
            "type": "object",
            "description": "Optional JSON schema to validate API responses against. If provided, schema changes will be detected.",
            "editor": "json",
            "prefill": {}
        },
        "alertWebhook": {
            "title": "Alert Webhook URL",
            "type": "string",
            "description": "Optional webhook URL to send alerts when changes or errors are detected.",
            "editor": "textfield",
            "prefill": ""
        },
        "requestTimeout": {
            "title": "Request Timeout (ms)",
            "type": "integer",
            "description": "Timeout for each API request in milliseconds.",
            "default": 30000
        },
        "maxRetries": {
            "title": "Max Retries",
            "type": "integer",
            "description": "Maximum number of retry attempts for failed requests.",
            "default": 3
        }
    },
    "required": ["apiEndpoints"]
}

.actor/output_schema.json

{
    "actorOutputSchemaVersion": 1,
    "title": "Output schema for API Endpoint Monitor",
    "properties": {
        "overview": {
            "type": "string",
            "title": "API Monitoring Results",
            "template": "{{links.apiDefaultDatasetUrl}}/items?view=overview"
        }
    }
}

src/main.js

1// Apify SDK - toolkit for building Apify Actors (Read more at https://docs.apify.com/sdk/js/)
2import { Actor } from 'apify';
3// Crawlee - web scraping and browser automation library (Read more at https://crawlee.dev)
4import { CheerioCrawler, Dataset } from 'crawlee';
5
6// The init() call configures the Actor for its environment. It's recommended to start every Actor with an init()
7await Actor.init();
8
9// Structure of input is defined in input_schema.json
10const {
11    apiEndpoints = ['https://jsonplaceholder.typicode.com/posts'],
12    httpMethod = 'GET',
13    authHeaders = {},
14    requestBody = {},
15    expectedSchema = {},
16    alertWebhook = '',
17    requestTimeout = 30000,
18    maxRetries = 3,
19} = (await Actor.getInput()) ?? {};
20
21// Validate input
22if (!apiEndpoints || apiEndpoints.length === 0) {
23    throw new Error('At least one API endpoint is required');
24}
25
26// Proxy configuration to rotate IP addresses and prevent blocking (https://docs.apify.com/platform/proxy)
27const proxyConfiguration = await Actor.createProxyConfiguration();
28
29/**
30 * Infers a JSON schema from a sample data object
31 * @param {any} data - The data to infer schema from
32 * @param {string} path - Current path in the schema (for nested objects)
33 * @returns {object} - Inferred JSON schema
34 */
35function inferSchema(data, path = '') {
36    if (data === null) {
37        return { type: 'null' };
38    }
39
40    if (Array.isArray(data)) {
41        if (data.length === 0) {
42            return { type: 'array', items: {} };
43        }
44        // Infer schema from first item
45        return {
46            type: 'array',
47            items: inferSchema(data[0], `${path}[]`),
48        };
49    }
50
51    if (typeof data === 'object') {
52        const properties = {};
53        const required = [];
54
55        for (const [key, value] of Object.entries(data)) {
56            properties[key] = inferSchema(value, `${path}.${key}`);
57            required.push(key);
58        }
59
60        return {
61            type: 'object',
62            properties,
63            required,
64        };
65    }
66
67    // Primitive types
68    return { type: typeof data };
69}
70
71/**
72 * Compares two schemas and returns differences
73 * @param {object} expected - Expected schema
74 * @param {object} actual - Actual inferred schema
75 * @param {string} path - Current path for error messages
76 * @returns {string[]} - Array of differences found
77 */
78function compareSchemas(expected, actual, path = 'root') {
79    const differences = [];
80
81    if (!expected || Object.keys(expected).length === 0) {
82        return differences; // No expected schema to compare against
83    }
84
85    if (expected.type !== actual.type) {
86        differences.push(`Type mismatch at ${path}: expected "${expected.type}", got "${actual.type}"`);
87        return differences;
88    }
89
90    if (expected.type === 'object' && expected.properties) {
91        const expectedKeys = new Set(Object.keys(expected.properties || {}));
92        const actualKeys = new Set(Object.keys(actual.properties || {}));
93
94        // Check for missing fields
95        for (const key of expectedKeys) {
96            if (!actualKeys.has(key)) {
97                differences.push(`Missing field at ${path}.${key}`);
98            } else {
99                // Recursively compare nested objects
100                differences.push(...compareSchemas(expected.properties[key], actual.properties[key], `${path}.${key}`));
101            }
102        }
103
104        // Check for new fields
105        for (const key of actualKeys) {
106            if (!expectedKeys.has(key)) {
107                differences.push(`New field at ${path}.${key}`);
108            }
109        }
110    }
111
112    if (expected.type === 'array' && expected.items) {
113        differences.push(...compareSchemas(expected.items, actual.items || {}, `${path}[]`));
114    }
115
116    return differences;
117}
118
119/**
120 * Generates OpenAPI-style documentation for an endpoint
121 * @param {string} endpoint - The API endpoint URL
122 * @param {string} method - HTTP method
123 * @param {object} responseData - Sample response data
124 * @param {object} responseHeaders - Response headers
125 * @param {number} statusCode - HTTP status code
126 * @returns {object} - OpenAPI-style documentation
127 */
128function generateOpenAPIDoc(endpoint, method, responseData, responseHeaders, statusCode) {
129    const url = new URL(endpoint);
130    const contentType = responseHeaders['content-type'] || 'application/json';
131
132    return {
133        openapi: '3.0.0',
134        info: {
135            title: `API Documentation for ${url.hostname}`,
136            version: '1.0.0',
137            description: `Auto-generated documentation for ${endpoint}`,
138        },
139        servers: [
140            {
141                url: `${url.protocol}//${url.host}`,
142                description: 'API Server',
143            },
144        ],
145        paths: {
146            [url.pathname + url.search]: {
147                [method.toLowerCase()]: {
148                    summary: `${method} ${url.pathname}`,
149                    responses: {
150                        [statusCode]: {
151                            description: 'Successful response',
152                            content: {
153                                [contentType.split(';')[0]]: {
154                                    schema: inferSchema(responseData),
155                                },
156                            },
157                        },
158                    },
159                },
160            },
161        },
162    };
163}
164
165/**
166 * Sends an alert to the configured webhook
167 * @param {string} webhookUrl - The webhook URL
168 * @param {object} alertData - The alert data to send
169 */
170async function sendAlert(webhookUrl, alertData) {
171    if (!webhookUrl) return;
172
173    try {
174        const response = await fetch(webhookUrl, {
175            method: 'POST',
176            headers: { 'Content-Type': 'application/json' },
177            body: JSON.stringify(alertData),
178        });
179
180        if (!response.ok) {
181            console.warn(`Failed to send alert: ${response.status} ${response.statusText}`);
182        }
183    } catch (error) {
184        console.warn(`Error sending alert: ${error.message}`);
185    }
186}
187
188/**
189 * Makes an API request with retry logic
190 * @param {string} url - The API endpoint URL
191 * @param {object} options - Fetch options
192 * @param {number} retries - Number of retries remaining
193 * @returns {Promise<{response: Response, responseTime: number}>}
194 */
195async function fetchWithRetry(url, options, retries = maxRetries) {
196    const startTime = Date.now();
197
198    try {
199        const response = await fetch(url, options);
200        const responseTime = Date.now() - startTime;
201        return { response, responseTime };
202    } catch (error) {
203        if (retries > 0) {
204            // Exponential backoff
205            const delay = Math.pow(2, maxRetries - retries) * 1000;
206            await new Promise((resolve) => setTimeout(resolve, delay));
207            return fetchWithRetry(url, options, retries - 1);
208        }
209        throw error;
210    }
211}
212
213// Process each API endpoint
214const results = [];
215
216for (const endpoint of apiEndpoints) {
217    console.log(`Monitoring endpoint: ${endpoint}`);
218
219    const result = {
220        endpoint,
221        status: null,
222        responseTime: null,
223        responseHeaders: {},
224        schemaValid: true,
225        changesDetected: false,
226        schemaChanges: [],
227        generatedDocs: null,
228        error: null,
229        timestamp: new Date().toISOString(),
230    };
231
232    try {
233        // Prepare fetch options
234        const fetchOptions = {
235            method: httpMethod,
236            headers: {
237                Accept: 'application/json',
238                'Content-Type': 'application/json',
239                ...authHeaders,
240            },
241            signal: AbortSignal.timeout(requestTimeout),
242        };
243
244        // Add body for POST/PUT/PATCH requests
245        if (['POST', 'PUT', 'PATCH'].includes(httpMethod) && Object.keys(requestBody).length > 0) {
246            fetchOptions.body = JSON.stringify(requestBody);
247        }
248
249        // Make the request
250        const { response, responseTime } = await fetchWithRetry(endpoint, fetchOptions);
251
252        result.status = response.status;
253        result.responseTime = responseTime;
254
255        // Capture response headers
256        response.headers.forEach((value, key) => {
257            result.responseHeaders[key] = value;
258        });
259
260        // Parse response body
261        let responseData;
262        const contentType = response.headers.get('content-type') || '';
263
264        if (contentType.includes('application/json')) {
265            responseData = await response.json();
266        } else {
267            responseData = await response.text();
268        }
269
270        // Infer schema from response
271        const inferredSchema = inferSchema(responseData);
272
273        // Compare with expected schema if provided
274        if (expectedSchema && Object.keys(expectedSchema).length > 0) {
275            const differences = compareSchemas(expectedSchema, inferredSchema);
276            if (differences.length > 0) {
277                result.schemaValid = false;
278                result.changesDetected = true;
279                result.schemaChanges = differences;
280
281                // Send alert if webhook is configured
282                await sendAlert(alertWebhook, {
283                    type: 'schema_change',
284                    endpoint,
285                    changes: differences,
286                    timestamp: result.timestamp,
287                });
288            }
289        }
290
291        // Generate OpenAPI documentation
292        result.generatedDocs = generateOpenAPIDoc(endpoint, httpMethod, responseData, result.responseHeaders, result.status);
293
294        console.log(`  Status: ${result.status}, Response time: ${result.responseTime}ms`);
295
296        // Alert on non-2xx status codes
297        if (result.status < 200 || result.status >= 300) {
298            await sendAlert(alertWebhook, {
299                type: 'status_error',
300                endpoint,
301                status: result.status,
302                timestamp: result.timestamp,
303            });
304        }
305    } catch (error) {
306        result.error = error.message;
307        console.error(`  Error: ${error.message}`);
308
309        // Send alert for errors
310        await sendAlert(alertWebhook, {
311            type: 'request_error',
312            endpoint,
313            error: error.message,
314            timestamp: result.timestamp,
315        });
316    }
317
318    results.push(result);
319
320    // Save result to dataset
321    await Dataset.pushData(result);
322}
323
324// Log summary
325console.log('\n--- Monitoring Summary ---');
326console.log(`Total endpoints monitored: ${results.length}`);
327console.log(`Successful: ${results.filter((r) => r.status >= 200 && r.status < 300).length}`);
328console.log(`Failed: ${results.filter((r) => r.error || r.status >= 400).length}`);
329console.log(`Schema changes detected: ${results.filter((r) => r.changesDetected).length}`);
330
331// Gracefully exit the Actor process. It's recommended to quit all Actors with an exit()
332await Actor.exit();

API Health Checker

wheat_tourist/api-health-checker

Monitor API endpoints with health scoring (0-100), performance ratings, and actionable insights. Checks availability, latency, and response validation. Retry logic with exponential backoff. Get recommendations for slow or failing endpoints. Perfect for uptime monitoring and SLA verification.

Varun Chopra

FlashScore Scraper Live

statanow/flashscore-scraper-live

Use this alternative FlashScore API to scrape live matches from FlashScore, including scores, status, league, kick-off time, detailed event history, and other sport stats. Export live match data, run the scraper using the API, manage and schedule runs, or integrate with external tools.

statanow

5.0

(3)

Instagram Profile Reposts Scraper

datadoping/instagram-profile-reposts-scraper

Extract Instagram profile reposts in bulk without requiring login, session ID, or cookies. This actor provides complete API support, and seamless export options, making large-scale follower collection efficient and reliable.

Data Doping

176

5.0

(3)

Pump.fun Real Time Monitor

muhammetakkurtt/pump-fun-real-time-monitor

Get real-time Solana meme token events from Pump.fun with this high-performance Apify Standby Actor. Instantly stream new token launches, live trades, and graduations via Server-Sent Events (SSE). With sub-second latency and no polling required, it's the ultimate tool for traders and developers.

Muhammet Akkurt

5.0

(2)

ESPN Scoreboard Monitor

notabotpromise/espn-scoreboard-monitor

Extract ESPN scoreboard data for NFL, NCAA College Football, NBA, WNBA, and MLB games. Supports live, upcoming, and completed games with flexible date range options.

Beep Boop

Local News & Reputation Monitor

alizarin_refrigerator-owner/local-news-monitor

Stay informed about local news coverage of your business, competitors, and industry. Catch PR opportunities, manage reputation risks, and identify link building possibilities.

John Rippy

TikTok Scraper

clockworks/tiktok-scraper

Extract data from TikTok videos, hashtags, and users. Use URLs or search queries to scrape TikTok profiles, hashtags, posts, URLs, shares, followers, hearts, names, video, and music-related data. Export scraped data, run the scraper via API, schedule and monitor runs or integrate with other tools.

Clockworks

114K

4.6

(180)

E-commerce Scraping Tool

apify/e-commerce-scraping-tool

Scrape data from e-commerce websites with E-commerce Scraping Tool. Scrape almost any retail site in minutes, extract e-commerce data and use it to monitor price details over time or compare different e-commerce sites’ offerings.

Apify

3.2K

4.6

(26)

Instagram Hashtag Scraper

apify/instagram-hashtag-scraper

Scrape Instagram posts and reels by hashtags. Just add one or more hashtags and extract captions, locations, likes, plays, shares, comments count, images, timestamps, audio, and other hashtags. Export scraped hashtags, run the scraper via API, schedule and monitor runs or integrate with other tools.

Apify

34K

4.3

(51)

TikTok Hashtag Scraper

clockworks/tiktok-hashtag-scraper

Scrape TikTok hashtag data. Just add one or more hashtags and extract TikTok videos with that hashtag: URLs, likes, country of creation, video and music metadata, TikTok creator data. Export scraped data, run the scraper via API, schedule and monitor runs or integrate with other tools.

Clockworks

7.8K

4.8

(18)

Api Endpoint Monitor

Api Endpoint Monitor

AGENTS.md

Dockerfile

package.json

.actor/actor.json

.actor/dataset_schema.json

.actor/input_schema.json

.actor/output_schema.json

src/main.js

You might also like

API Health Checker

FlashScore Scraper Live

Instagram Profile Reposts Scraper

Pump.fun Real Time Monitor

ESPN Scoreboard Monitor

Local News & Reputation Monitor

TikTok Scraper

E-commerce Scraping Tool

Instagram Hashtag Scraper

TikTok Hashtag Scraper

AGENTS.md

Dockerfile

package.json

.actor/actor.json

.actor/dataset_schema.json

.actor/input_schema.json

.actor/output_schema.json

src/main.js