Pricing

Pay per usage

Try for free

Go to Apify Store

Geo Availability Checker

Try for free

Checks whether a set of URLs are reachable, blocked, or redirected when accessed from specific countries, using residential proxies. Each check is an action — it runs, logs a pass/fail line to the run log, and charges for having happened. That's the whole output.

Pricing

Pay per usage

Rating

0.0

(0)

Developer

Hassan ali

Actor stats

Bookmarked

Total users

Monthly active users

25 days ago

Last modified

Categories

SEO tools

Automation

Developer tools

You can access the Geo Availability Checker programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in API & Integrations in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "1.2",
    "x-build-id": "G8D5PgJWMOmhfseEh"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/the_voyager~geo-availability-checker/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-the_voyager-geo-availability-checker",
        "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/the_voyager~geo-availability-checker/runs": {
      "post": {
        "operationId": "runs-sync-the_voyager-geo-availability-checker",
        "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/the_voyager~geo-availability-checker/run-sync": {
      "post": {
        "operationId": "run-sync-the_voyager-geo-availability-checker",
        "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",
        "required": [
          "proxyConfiguration"
        ],
        "properties": {
          "checks": {
            "title": "Explicit URL/country checks (advanced)",
            "type": "array",
            "description": "Optional. Exact list of {\"url\": \"...\", \"country\": \"US\", \"expected\": \"reachable\"} objects to run. If provided, this takes priority over urls + countries below.",
            "default": []
          },
          "urls": {
            "title": "URLs to check",
            "type": "array",
            "description": "List of URLs to check. Combined with every country below (every URL x every country) unless \"checks\" is set above.",
            "default": [
              "https://apify.com"
            ],
            "items": {
              "type": "string"
            }
          },
          "countries": {
            "title": "Countries to check from",
            "type": "array",
            "description": "Two-letter country codes (e.g. US, GB, FR, BR, JP) to route residential proxy traffic through for each URL.",
            "default": [
              "US"
            ],
            "items": {
              "type": "string"
            }
          },
          "expectedOutcome": {
            "title": "Expected outcome",
            "enum": [
              "any",
              "reachable",
              "blocked"
            ],
            "type": "string",
            "description": "What counts as a pass for the urls x countries combinations above. Ignored for any entry in \"checks\" that sets its own \"expected\".",
            "default": "any"
          },
          "timeoutSecs": {
            "title": "Request timeout (seconds)",
            "minimum": 5,
            "maximum": 120,
            "type": "integer",
            "description": "Per-check timeout before it's marked unreachable.",
            "default": 20
          },
          "maxConcurrency": {
            "title": "Max concurrency",
            "minimum": 1,
            "maximum": 20,
            "type": "integer",
            "description": "How many checks to run in parallel.",
            "default": 5
          },
          "proxyConfiguration": {
            "title": "Proxy configuration",
            "type": "object",
            "description": "Choose which residential proxy groups to use. The country for each check comes from \"countries\" / \"checks\" above, not from this field.",
            "default": {
              "useApifyProxy": true,
              "apifyProxyGroups": [
                "RESIDENTIAL"
              ]
            }
          }
        }
      },
      "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
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Geo Availability Checker OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for Geo Availability Checker from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

Geo Availability Checker API in Python

Geo Availability Checker API in JavaScript

Geo Availability Checker API through CLI

Geo Availability Checker API

Broken Link Checker - Dead Links, 404 Checker, Bulk URL Status

neverempty/link-checker

Checks every link on a page and says which state it is in: ok, not-found, blocked-to-us, server-error or unreachable. A 403 to this checker is reported as blocked, not broken. Falls back to GET when a server rejects HEAD, accepts every 2xx, and records the full redirect chain.

NeverEmpty

Website Email Scraper - Contact Details Extractor by Domain

neverempty/website-contacts

Finds emails, phone numbers and social profiles on any website. Decodes obfuscated addresses, refuses to invent ones that are not there, and tells you when a site blocked it instead of returning a blank row. Charges only when contacts are actually found.

NeverEmpty

Rightmove Listing Availability Checker

confidential_gnat/rightmove-listing-availability-checker

Actor that checks the availability of property listings on Rightmove. It takes a list of Rightmove listing URLs as input and verifies if each listing is still active or has been removed. The output includes the URL, availability status, and any relevant metadata for each listing.

ActorFlow

Log Scanner

lukaskrivka/log-scanner

Log scanner helps you to find particular text in your log files. It can scan [Apify](https://apify.com/) runs, tasks, or actors but also arbitrary text files. If you ever had a problem finding that one error in a thousand runs, this is a tool to use.

Lukáš Křivka

What Happened Today

easyapi/what-happened-today

Retrieve historical events, births, and deaths for any specific date. Get structured data about what happened on this day in history 📅

EasyApi

URL Content Change Monitor

engineertsaistudio/url-content-change-monitor

Fetches a URL, hashes a selected text region (or full page), and reports whether content changed since the last check. Pay-per-event: charges the buyer only when a real change is detected, not per poll.

Studio EngineerTsai

Scraper Results Checker

drobnikj/check-crawler-results

This actor checks results from Apify's scrapers or any other actor that stores its result to a dataset, and sends a notification if there are errors. It's designed to run from webhook.

Jakub Drobník

AI SEO & GEO Audit: Can ChatGPT & Perplexity Read Your Site?

hydrafetch/ai-seo-geo-audit

Check whether an LLM or AI agent can actually read your pages, and get the specific reasons when it cannot.

Hydrafetch

Username Checker

mina_safwat/username-checker

Checks whether a username is taken across hundreds of websites and returns the profile link wherever it exists

Mina

JSON Content Checker

scrapeworks/json-content-checker

Check and validate a list of JSON URLs or API endpoints in bulk: confirm each response is valid JSON, inspect its structure, assert that required fields and values are present, and get a stable content hash to detect when a feed changes.