# Actor Proxy Analyzer — Proxy Recs & Cost Savings (`ryanclinton/actor-proxy-analyzer`) Actor Actor Proxy Analyzer. Available on the Apify Store with pay-per-event pricing. - **URL**: https://apify.com/ryanclinton/actor-proxy-analyzer.md - **Developed by:** [ryan clinton](https://apify.com/ryanclinton) (community) - **Categories:** Developer tools, Automation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing $250.00 / 1,000 proxy analyzers 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/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. 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. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use 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 ## Proxy Analyzer — Optimize Proxy Types Across Your Actor Fleet Proxy Analyzer scans your entire Apify actor portfolio and recommends the optimal proxy type for every actor. It detects which platform each actor targets, maps that platform to the correct proxy tier (Datacenter, Residential, or SERP), and surfaces every actor where you are likely overspending. Developers with 20+ actors in their fleet typically recover $10–50/month in unnecessary proxy costs after a single analysis. The actor reads metadata from the Apify API — it does not trigger any actor runs. The entire fleet scan completes in seconds. No configuration required; the analyzer uses your account token automatically. ### What data can you extract? | Data Point | Source | Example | |------------|--------|---------| | 📋 **Per-actor proxy recommendation** | Platform name matching | `RESIDENTIAL` for linkedin-scraper | | 🔍 **Detected target platform** | Name, title, description scan | `linkedin`, `amazon`, `google` | | 💰 **Proxy cost tier** | Relative multiplier | `SERP` costs 12x datacenter baseline | | 📊 **Fleet-wide breakdown** | Aggregated counts | `30 DATACENTER, 12 RESIDENTIAL, 3 SERP` | | 🏷️ **Actor name and ID** | Apify API | `ryanclinton/google-maps-email-extractor` | | ⚠️ **No-proxy candidates** | Category classification | API/tool actors flagged as `NONE` | | 💡 **Optimization tips** | Fleet analysis | "8 actors don't need proxies at all" | | 🕐 **Analysis timestamp** | Run metadata | `2026-03-20T14:32:00.000Z` | ### Why use Proxy Analyzer? Proxy costs are one of the biggest variables in an Apify actor's operating budget, but most developers configure proxies once and never revisit them. An actor scraping Yelp (which works fine with datacenter proxies) running on residential proxies costs 8x more per request than it needs to. Multiply that across a portfolio of 30, 50, or 100 actors and the waste adds up fast. This actor automates the entire audit. It reads every actor in your account, detects the target platform from the actor's name, title, and description, and maps it to the correct proxy tier using a curated platform knowledge base covering 13 major platforms. You get a full fleet report in seconds, not hours of manual investigation. - **Scheduling** — run monthly to catch newly added actors before they accumulate proxy costs - **API access** — trigger from Python, JavaScript, or any HTTP client as part of your portfolio review pipeline - **Proxy rotation** — the analyzer itself runs with minimal overhead (128MB RAM, no browser) - **Monitoring** — combine with [Cost Watchdog](https://apify.com/ryanclinton/cost-watchdog) for automated spend alerts - **Integrations** — push the report to Google Sheets, Slack, or your cost tracking dashboard via webhook ### Features - **13-platform knowledge base** — covers LinkedIn, Facebook, Instagram, X/Twitter, TikTok, Amazon, Google, YouTube, Indeed, Glassdoor, Zillow, Yelp, and Reddit with verified proxy tier requirements - **Three-tier proxy classification** — maps every actor to DATACENTER (baseline cost), RESIDENTIAL (8x multiplier), or SERP (12x multiplier) based on target platform - **API actor detection** — identifies actors in the AI, DEVELOPER_TOOLS, and INTEGRATIONS categories that require no proxy at all, so you can eliminate unnecessary proxy configuration on tool actors - **Platform detection from metadata** — searches actor name, title, and description text for platform keywords; no code inspection required - **Cost-savings prioritization** — output is sorted with RESIDENTIAL recommendations first, then SERP, then DATACENTER, so the highest-impact changes appear at the top - **Fleet-wide aggregation** — `byProxyType` field gives a single-glance breakdown of your entire portfolio's proxy distribution - **Optimization tips array** — plain-English recommendations with specific actor counts, ready to paste into a Slack message or ticket - **Zero actor runs** — reads only the Apify REST API `/acts` endpoint; does not trigger any child runs or incur downstream costs - **Instant execution** — full fleet scan (up to 500 actors) completes in under 10 seconds with 128MB memory - **PPE charging model** — charges exactly $0.25 per analysis run, regardless of fleet size ### Use cases for Apify proxy analyzer #### Proxy cost auditing for large actor portfolios Developers maintaining 20+ actors often find that proxy configuration drifts over time. An actor originally built for a residential-only platform may have been copied and adapted for a public-data site, but the proxy setting was never updated. Proxy Analyzer surfaces every actor where the proxy tier is likely wrong, giving you a concrete action list to reduce monthly costs without touching any actor code. #### Onboarding new actors to correct proxy settings Before publishing a new actor, run Proxy Analyzer to confirm the recommended proxy tier for the target platform. The knowledge base reflects real-world blocking behavior — for example, LinkedIn and Instagram consistently block datacenter IPs, while Yelp and Reddit public data is reliably accessible via datacenter. Setting the right proxy from day one prevents failed runs and unnecessary spend. #### Monthly cost review and reporting Finance-conscious developer teams running Apify actors at scale can incorporate Proxy Analyzer into a monthly cost review workflow. Schedule it to run at the start of each month, push the output to a Google Sheet, and track how your fleet's proxy distribution changes as new actors are added. Combine with [Cost Watchdog](https://apify.com/ryanclinton/cost-watchdog) to get automated alerts when monthly proxy spend crosses a threshold. #### Pre-launch proxy validation When building an actor targeting a new platform not yet in your portfolio, Proxy Analyzer provides an authoritative reference for which proxy tier that platform requires. Instead of trial-and-error (which wastes runs and credits), consult the knowledge base output to set the correct proxy from the first test run. #### Actor portfolio documentation Teams maintaining internal actor portfolios for enterprise clients often need documentation of why each actor uses a specific proxy type. The Proxy Analyzer output — with `detectedPlatform`, `recommendedProxy`, and `reason` fields per actor — serves as auto-generated proxy configuration documentation that stays current with the portfolio. #### ApifyForge dashboard integration Proxy Analyzer is one of the core backend intelligence actors for the [ApifyForge](https://apifyforge.com) developer dashboard. It feeds the proxy optimization view, which shows portfolio-level proxy distribution alongside cost trend data. If you are building a similar Apify portfolio management tool, this actor provides the proxy analysis data layer. ### How to analyze your Apify proxy configuration 1. **No input needed** — open the actor, click "Start". The analyzer reads your actor list using the API token from your Apify account automatically. No URLs, no configuration. 2. **Wait 10–30 seconds** — the actor fetches your full actor list (up to 500 actors) and classifies each one. The status bar shows "Analyzing proxy usage..." while running. 3. **Review the results** — the Dataset tab shows one record: the full fleet report with `recommendations` sorted by highest-cost proxy type first. Start with the RESIDENTIAL section. 4. **Apply the changes** — for each actor flagged as using the wrong proxy tier, update the proxy configuration in that actor's input schema or default settings. Recalculate your expected monthly spend. ### Input parameters No input parameters are required. The actor takes zero configuration. | Parameter | Type | Required | Default | Description | |-----------|------|----------|---------|-------------| | *(none)* | — | — | — | The actor uses your Apify API token from the environment automatically | #### Input examples **Standard run (no input needed):** ```json {} ```` **The actor accepts an empty input object. All configuration is derived from the account token.** #### Input tips - **No setup required** — click Start from the Apify console and the analyzer runs against your account immediately. - **Run as a scheduled task** — add a monthly schedule to catch proxy drift as your fleet grows. Go to the actor's Schedules tab and set a cron to run on the 1st of each month. - **Check the tips array first** — the `tips` field in the output gives the highest-impact recommendations in plain English before you dive into the full `recommendations` list. ### Output example ```json { "totalActors": 47, "byProxyType": { "DATACENTER": 28, "RESIDENTIAL": 15, "SERP": 2, "NONE": 2 }, "recommendations": [ { "actorName": "ryanclinton/linkedin-profile-scraper", "actorId": "abc123XYZdef", "detectedPlatform": "linkedin", "recommendedProxy": "RESIDENTIAL", "reason": "LinkedIn blocks datacenter IPs aggressively" }, { "actorName": "ryanclinton/instagram-post-scraper", "actorId": "def456UVWghi", "detectedPlatform": "instagram", "recommendedProxy": "RESIDENTIAL", "reason": "Instagram requires residential IPs" }, { "actorName": "ryanclinton/google-maps-email-extractor", "actorId": "ghi789RSTjkl", "detectedPlatform": "google", "recommendedProxy": "SERP", "reason": "Google search requires SERP proxies for reliable results" }, { "actorName": "ryanclinton/yelp-business-scraper", "actorId": "jkl012OPQmno", "detectedPlatform": "yelp", "recommendedProxy": "DATACENTER", "reason": "Yelp public data accessible via datacenter" }, { "actorName": "ryanclinton/bulk-email-verifier", "actorId": "mno345LMNpqr", "detectedPlatform": null, "recommendedProxy": "NONE", "reason": "API/tool actor — no web scraping, no proxy needed" } ], "tips": [ "15 actors need residential proxies — these cost ~8x more than datacenter", "2 actors don't need proxies at all — ensure they're not configured with one", "2 actors need SERP proxies for search engine scraping" ], "analyzedAt": "2026-03-20T14:32:07.843Z" } ``` ### Output fields | Field | Type | Description | |-------|------|-------------| | `totalActors` | number | Total number of actors found in your account | | `byProxyType` | object | Count of actors per recommended proxy type | | `byProxyType.DATACENTER` | number | Actors where datacenter proxies are sufficient | | `byProxyType.RESIDENTIAL` | number | Actors requiring residential proxies | | `byProxyType.SERP` | number | Actors requiring SERP proxies (Google search) | | `byProxyType.NONE` | number | API/tool actors requiring no proxy | | `recommendations` | array | Per-actor recommendations sorted by proxy cost (highest first) | | `recommendations[].actorName` | string | Full actor name in `username/name` format | | `recommendations[].actorId` | string | Apify actor ID | | `recommendations[].detectedPlatform` | string or null | Platform keyword detected from actor metadata | | `recommendations[].recommendedProxy` | string | `DATACENTER`, `RESIDENTIAL`, `SERP`, or `NONE` | | `recommendations[].reason` | string | Human-readable explanation for the recommendation | | `tips` | array | Plain-English optimization tips with actor counts | | `analyzedAt` | string | ISO 8601 timestamp of when the analysis was run | ### How much does it cost to analyze your proxy configuration? Proxy Analyzer uses **pay-per-event pricing** — you pay **$0.25 per analysis run**. Platform compute costs are included. Fleet size does not affect the price. | Scenario | Runs | Cost per run | Total cost | |----------|------|-------------|------------| | Quick test | 1 | $0.25 | $0.25 | | Weekly review | 4 | $0.25 | $1.00 | | Monthly (1 run/month) | 1 | $0.25 | $0.25/month | | Quarterly audit | 4 runs/year | $0.25 | $1.00/year | | Full pipeline with Cost Watchdog | 1 + 1 | $0.25 + $0.25 | $0.50 | You can set a **maximum spending limit** per run to control costs. The actor stops when your budget is reached. Compare this to manually auditing proxy settings across a 50-actor fleet — 2–3 hours of work that this actor replaces for $0.25. ### Proxy analysis using the API #### Python ```python from apify_client import ApifyClient client = ApifyClient("YOUR_API_TOKEN") run = client.actor("ryanclinton/actor-proxy-analyzer").call(run_input={}) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(f"Total actors: {item['totalActors']}") print(f"Breakdown: {item['byProxyType']}") for rec in item.get("recommendations", [])[:5]: print(f" {rec['actorName']}: {rec['recommendedProxy']} — {rec['reason']}") for tip in item.get("tips", []): print(f"TIP: {tip}") ``` #### JavaScript ```javascript import { ApifyClient } from "apify-client"; const client = new ApifyClient({ token: "YOUR_API_TOKEN" }); const run = await client.actor("ryanclinton/actor-proxy-analyzer").call({}); const { items } = await client.dataset(run.defaultDatasetId).listItems(); for (const item of items) { console.log(`Total actors: ${item.totalActors}`); console.log(`By proxy type:`, item.byProxyType); for (const rec of item.recommendations.slice(0, 5)) { console.log(`${rec.actorName}: ${rec.recommendedProxy} — ${rec.reason}`); } for (const tip of item.tips) { console.log(`TIP: ${tip}`); } } ``` #### cURL ```bash ## Start the actor run curl -X POST "https://api.apify.com/v2/acts/ryanclinton~actor-proxy-analyzer/runs?token=YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{}' ## Fetch results (replace DATASET_ID from the run response) curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN&format=json" ``` ### How Proxy Analyzer works #### Phase 1 — Fleet enumeration The actor calls the Apify REST API endpoint `GET /v2/acts?my=true&limit=500` using the account token from the environment. This returns up to 500 actors owned by the account, including each actor's `name`, `title`, `description`, and `categories` fields. The request has a 30-second timeout. If the API call fails, the actor logs an error and exits cleanly without charging. #### Phase 2 — Platform keyword matching For each actor, the analyzer builds a search string by concatenating `name`, `title`, and `description` (all lowercased). It then tests this string against 13 platform keywords in the `PLATFORM_PROXY` lookup table. The first matching platform wins — matching stops at the first hit to prevent double-classification. Unmatched actors default to DATACENTER. The platform-to-proxy mapping reflects documented blocking behavior: - **RESIDENTIAL** — LinkedIn, Facebook, Instagram, X/Twitter, TikTok, Amazon, Indeed, Glassdoor - **SERP** — Google search (12x cost multiplier vs datacenter baseline) - **DATACENTER** — YouTube, Zillow, Yelp, Reddit (public data endpoints) #### Phase 3 — API actor override After platform matching, the analyzer checks each actor's `categories` array. Actors in `AI`, `DEVELOPER_TOOLS`, or `INTEGRATIONS` categories that had no platform detected are reclassified as `NONE` — meaning no proxy configuration is needed. This prevents tool actors, MCP servers, and API wrappers from being incorrectly recommended datacenter proxies. #### Phase 4 — Report assembly and sorting The recommendations array is sorted with a priority order: RESIDENTIAL (0) → SERP (1) → DATACENTER (2) → NONE (3). This surfaces the highest-cost proxy requirements first, making it immediately clear where the largest cost savings are available. Aggregated counts are written to `byProxyType`, and plain-English tips are generated from those counts. The complete report is pushed as a single dataset record. ### Tips for best results 1. **Act on RESIDENTIAL recommendations first.** Residential proxies cost 8x the datacenter baseline, so reclassifying even one high-volume actor from RESIDENTIAL to DATACENTER can pay for dozens of analysis runs. 2. **Check the NONE candidates carefully.** API/tool actors flagged as needing no proxy should have their proxy configuration explicitly set to `none` in their input schema defaults. Actors that default to datacenter proxies when they do not need them still incur small unnecessary costs at scale. 3. **Run after adding new actors.** Platform detection is based on actor metadata, not actor code. When you add a new actor to your portfolio, run Proxy Analyzer to confirm it is classified correctly before the first production run. 4. **Combine with Cost Watchdog for full visibility.** Proxy Analyzer tells you which proxy types your actors should use. [Cost Watchdog](https://apify.com/ryanclinton/cost-watchdog) tells you how much each actor is actually spending. Use both together to confirm that proxy changes translate into real cost reductions. 5. **Update actor metadata if classification is wrong.** If an actor is misclassified because the target platform is not obvious from the name or description, add the platform name to the actor's description. This makes the next analysis run produce the correct recommendation automatically. 6. **Schedule monthly, not daily.** Proxy requirements for a given platform do not change frequently. A monthly schedule is sufficient for most portfolios. Daily runs add $7.50/month without meaningful new information. 7. **Export to CSV for team review.** Download the dataset as CSV from the Apify console and share it with team members who manage actor deployment. The `recommendations` array flattens cleanly to a spreadsheet. ### Combine with other Apify actors | Actor | How to combine | |-------|----------------| | [Cost Watchdog](https://apify.com/ryanclinton/cost-watchdog) | After identifying actors with wrong proxy types, use Cost Watchdog to measure actual spend before and after fixing them | | [Actor Plan Advisor](https://apify.com/ryanclinton/actor-plan-advisor) | Proxy cost reductions lower total monthly spend, which can shift your optimal Apify plan — run Plan Advisor after applying proxy changes | | [Actor Health Monitor](https://apify.com/ryanclinton/actor-health-monitor) | Actors running with wrong proxy types often produce failed runs — Health Monitor surfaces those failure patterns | | [B2B Lead Gen Suite](https://apify.com/ryanclinton/b2b-lead-gen-suite) | Multi-actor lead generation pipelines have complex proxy needs across different target platforms — use Proxy Analyzer to audit the full pipeline | | [Google Maps Email Extractor](https://apify.com/ryanclinton/google-maps-email-extractor) | Google Maps actors are correctly classified as needing SERP proxies — Proxy Analyzer confirms this and flags if another actor in your fleet is scraping Google without SERP proxies | | [Website Contact Scraper](https://apify.com/ryanclinton/website-contact-scraper) | Generic website scrapers default to DATACENTER in the analysis — confirm this matches your target sites before scaling | | [Waterfall Contact Enrichment](https://apify.com/ryanclinton/waterfall-contact-enrichment) | Multi-step enrichment pipelines may call several platforms — each step's proxy needs should be audited separately | ### Limitations - **Platform detection is metadata-based, not code-based.** The analyzer reads actor names, titles, and descriptions — not the actual source code. An actor scraping LinkedIn but named "profile-data-collector" will not be detected as a LinkedIn actor and will default to DATACENTER. - **13 platforms covered.** The knowledge base covers the 13 most common platforms. Actors targeting platforms like Booking.com, Airbnb, Etsy, or Pinterest are classified as DATACENTER by default, which may not be correct for those platforms. - **No current proxy configuration reading.** The analyzer recommends what proxy each actor should use but cannot read what proxy the actor is currently configured to use. You must compare the recommendation against your actor's actual proxy settings manually. - **500-actor limit.** The Apify API returns a maximum of 500 actors per call. Accounts with more than 500 actors will have the excess actors omitted from the analysis. - **Categories heuristic has false positives.** An actor in the AI category that actually scrapes web data will be incorrectly flagged as needing no proxy. Verify NONE recommendations for actors that do perform web scraping. - **Proxy cost multipliers are approximate.** The 8x residential and 12x SERP multipliers are representative baselines. Actual Apify proxy pricing varies by plan and volume — check the [Apify pricing page](https://apify.com/pricing) for current rates. - **Runs once per analysis.** The actor does not continuously monitor proxy configuration. Schedule it periodically if you want ongoing coverage. ### Integrations - [Zapier](https://apify.com/integrations/zapier) — trigger Proxy Analyzer monthly and push the tips array to a Slack channel automatically - [Make](https://apify.com/integrations/make) — build a workflow that runs Proxy Analyzer, parses RESIDENTIAL recommendations, and creates tickets in Jira or Trello for each actor to update - [Google Sheets](https://apify.com/integrations/google-sheets) — export the recommendations array to a spreadsheet for team review and cost tracking - [Apify API](https://docs.apify.com/api/v2) — call from your CI/CD pipeline to validate proxy settings before deploying new actors to production - [Webhooks](https://docs.apify.com/platform/integrations/webhooks) — trigger a downstream notification workflow when analysis completes, routing the report to Slack, email, or a cost dashboard - [LangChain / LlamaIndex](https://docs.apify.com/platform/integrations) — feed the proxy report into an LLM workflow that generates a natural-language cost optimization memo for stakeholders ### Troubleshooting - **All actors show DATACENTER despite targeting protected platforms** — Check that your actor names and titles clearly reference the target platform. The analyzer detects platforms from text in `name`, `title`, and `description`. An actor named `data-collector-v2` will not be detected as a LinkedIn actor — add "LinkedIn" to the description to fix classification. - **API actors are not being flagged as NONE** — The NONE classification applies only to actors in the AI, DEVELOPER\_TOOLS, or INTEGRATIONS categories. If your API wrapper actors are in a different category (e.g., LEAD\_GENERATION), they will default to DATACENTER. Recategorize those actors in the Apify console and re-run the analysis. - **Run fails with "Failed to list actors" error** — This means the Apify API call to `/v2/acts` returned an error. The most common cause is a rate limit or a temporary API outage. Wait a few minutes and re-run. If the issue persists, check the [Apify status page](https://status.apify.com). - **Fewer actors in the report than expected** — The API call fetches a maximum of 500 actors. If your account has more than 500 actors, the excess are not analyzed in the current run. This limit is set by the Apify API and cannot be raised within the current architecture. - **SERP proxy flagged for non-Google actors** — If an actor's name or description contains the word "google" in a non-search context (e.g., "google-sheets-exporter"), it will be classified as needing SERP proxies. Update the actor's description to remove or qualify the platform reference, or ignore the SERP recommendation for that actor. ### Responsible use - This actor only reads actor metadata from the Apify API using your own account credentials. - No external websites are accessed; no scraping of third-party services occurs. - The analysis is performed entirely against your own account data. - For guidance on web scraping legality in general, see [Apify's guide](https://blog.apify.com/is-web-scraping-legal/). ### FAQ **How does Proxy Analyzer detect which proxy type my actor needs?** The actor reads each actor's `name`, `title`, and `description` fields from the Apify API and searches for platform keywords in that combined text. It matches against 13 known platforms (LinkedIn, Facebook, Instagram, X/Twitter, TikTok, Amazon, Google, YouTube, Indeed, Glassdoor, Zillow, Yelp, Reddit) and maps each to the verified proxy tier for that platform. Actors with no platform match default to DATACENTER. **How many actors can Proxy Analyzer scan in one run?** Up to 500 actors per run. This is the maximum returned by the Apify API's `/v2/acts` endpoint in a single request. The entire scan completes in under 30 seconds regardless of fleet size. **Does Proxy Analyzer actually run any of my actors?** No. It calls only the Apify REST API to read actor metadata. No child actor runs are triggered, and no compute costs beyond the $0.25 analysis fee are incurred. **How accurate is the proxy type recommendation?** For the 13 covered platforms, the recommendations reflect documented blocking behavior that is consistent across the Apify community. LinkedIn, Instagram, Facebook, TikTok, Amazon, Indeed, and Glassdoor block datacenter IPs reliably. Google search requires SERP proxies. YouTube, Zillow, Yelp, and Reddit public endpoints work with datacenter proxies. Actors targeting unlisted platforms default to DATACENTER, which may not be correct for all sites. **Why does the NONE recommendation matter?** API and tool actors that are configured with any proxy — even datacenter — pay for proxy bandwidth they do not use. On high-volume tool actors, this is a small but unnecessary cost. Setting proxies to `none` for API actors also speeds up requests slightly by eliminating proxy connection overhead. **How is Proxy Analyzer different from manually checking each actor?** Manual review of 50 actors takes 2–3 hours: open each actor, read the description, look up what proxy it needs, check the current configuration. Proxy Analyzer does the same classification in under 30 seconds for $0.25. The actor also sorts results by cost impact, so you see the highest-savings opportunities immediately. **Can I schedule Proxy Analyzer to run automatically?** Yes. Open the actor in the Apify console, go to the Schedules tab, and create a cron schedule. A monthly run on the 1st of each month is sufficient for most portfolios. You can combine this with a webhook to push the report to Slack or email when the run completes. **What happens if an actor targets a platform not in the knowledge base?** It will be classified as DATACENTER by default. If the actor targets a platform that requires residential or SERP proxies (e.g., Booking.com, Airbnb), the recommendation will be incorrect. In this case, you can override it manually — the output shows `detectedPlatform: null` for unmatched actors, making them easy to identify. **Is it legal to read actor metadata from the Apify API?** Yes. This actor reads only your own account data using your own API token. It accesses the Apify API under your account's terms of service, the same way the Apify console does. **Can I use Proxy Analyzer for actors published by other users?** No. The API call uses `my=true`, which returns only actors owned by the authenticated account. You cannot analyze another user's actor portfolio. **How often should I run Proxy Analyzer?** Once per month is sufficient for most portfolios. Run it immediately after adding new actors to your portfolio, and after Apify announces changes to proxy pricing or availability — those events may change which proxy tier is optimal for a given platform. **Does Proxy Analyzer work with Apify's free tier?** Yes. The actor costs $0.25 per run, and Apify's free tier includes $5 of monthly credits. That covers 20 analysis runs per month before any paid usage. For most developers, a single monthly run is all that is needed. ### Help us improve If you encounter issues, you can help us debug faster by enabling run sharing in your Apify account: 1. Go to [Account Settings > Privacy](https://console.apify.com/account/privacy) 2. Enable **Share runs with public Actor creators** This lets us see your run details when something goes wrong, so we can fix issues faster. Your data is only visible to the actor developer, not publicly. ### Support Found a bug or have a feature request? Open an issue in the [Issues tab](https://console.apify.com/actors/ryanclinton~actor-proxy-analyzer/issues) on this actor's page. For custom solutions or enterprise integrations, reach out through the Apify platform. # Actor input Schema ## Actor input object example ```json {} ``` # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = {}; // Run the Actor and wait for it to finish const run = await client.actor("ryanclinton/actor-proxy-analyzer").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = {} # Run the Actor and wait for it to finish run = client.actor("ryanclinton/actor-proxy-analyzer").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 '{}' | apify call ryanclinton/actor-proxy-analyzer --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=ryanclinton/actor-proxy-analyzer", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Actor Proxy Analyzer — Proxy Recs & Cost Savings", "description": "Actor Proxy Analyzer. Available on the Apify Store with pay-per-event pricing.", "version": "1.0", "x-build-id": "3iLEpofXBH7sI3gpj" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/ryanclinton~actor-proxy-analyzer/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-ryanclinton-actor-proxy-analyzer", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/ryanclinton~actor-proxy-analyzer/runs": { "post": { "operationId": "runs-sync-ryanclinton-actor-proxy-analyzer", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/ryanclinton~actor-proxy-analyzer/run-sync": { "post": { "operationId": "run-sync-ryanclinton-actor-proxy-analyzer", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "properties": {} }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```