AI Agent URL & API Compatibility Checker

AI agent URL and API preflight checker

Validate public URLs and API endpoints before an AI agent, MCP tool, RAG pipeline, crawler, scraper, or browser client depends on them.

This Actor is designed for a simple decision: can this public URL be used reliably by an automated system?

It checks 1-100 public HTTP/HTTPS URLs and returns structured JSON with HTTP status, final URL, redirect chain, content type, TLS certificate state, CORS behavior, server-agent readiness, and browser-client readiness.

When to use this Actor

Use this Actor when you need to:

• validate URLs before adding them to an AI agent or automation workflow
• check whether a public API endpoint is reachable and what format it returns
• preflight web sources before adding them to RAG or retrieval pipelines
• inspect redirect chains before a crawler, scraper, or agent follows a URL
• check TLS certificate validity and upcoming expiry risk
• check CORS behavior for browser-based AI clients
• distinguish server-side accessibility from browser-client compatibility
• batch-check up to 100 public URLs without using an LLM

Typical search intents include AI agent URL checker, API preflight checker, URL compatibility checker, CORS checker, TLS/SSL checker, redirect checker, MCP URL validation, and RAG source validation.

What each URL result contains

Each processed URL produces one dataset item with fields such as:

• requested_url - original public URL
• final_url - final destination after redirects
• http_status - returned HTTP status code
• content_type and format_hint - HTML, JSON, XML, CSV, text, or other
• redirect_count and redirect_chain - redirect behavior
• server_agent_readiness - whether a server-side agent can use the URL directly
• server_agent_reasons - reasons for blocked or caution states
• browser_client_readiness - browser-client compatibility based on CORS behavior
• browser_client_reasons - reasons for browser compatibility warnings
• tls - TLS version, issuer, validity, hostname verification, and expiry information
• cors - Access-Control-Allow-Origin and related CORS metadata
• evidence - per-probe success indicators

Readiness values are intended as deterministic network diagnostics, not as a guarantee that a third-party service will remain available.

Input

Provide urls as an array of 1-100 unique public HTTP/HTTPS URLs.

Example:

{
  "urls": [
    "https://example.com",
    "https://jsonplaceholder.typicode.com/users"
  ]
}

Output for AI, MCP, and automation workflows

Results are stored as one structured dataset item per processed URL. The Actor uses no LLM, so the output is deterministic and can be consumed directly by AI agents, MCP workflows, API clients, RAG ingestion pipelines, monitoring jobs, or custom automation.

A calling system can use the readiness fields to decide whether to continue, retry, use a browser-capable path, request authentication, or reject the URL.

Safety and scope

• Public HTTP/HTTPS targets only
• localhost and private/non-public IP targets are rejected
• non-public DNS targets are rejected
• no authenticated browsing or credential handling
• no JavaScript browser rendering
• no LLM calls
• maximum 100 URLs per run

Pricing

Pay per event: $0.001 per completed URL profile, plus the small Actor start event shown by Apify.

You are charged for completed url-profile events. The primary billable event is one completed public URL compatibility profile.

Example use cases

Check URLs before an AI agent uses them

Batch-test candidate tools, APIs, documentation pages, or data sources before passing them to an autonomous agent.

Validate RAG and retrieval sources

Check whether retrieval URLs resolve successfully, return usable content types, and have stable TLS before ingestion.

Diagnose browser-agent failures

Compare server-side reachability with CORS-based browser-client readiness to identify why a URL works from a backend but fails from a browser application.

Preflight public API endpoints

Confirm status, redirects, JSON/content type, TLS, and CORS before integrating a public endpoint into an automated workflow.