100 Services from http--forest-gas-station-mainnet--lcjl27p8lmjs.code.run

Resolves a bare public domain name into its registration, DNS, HTTPS/TLS, and mail-policy state using RDAP, DNS, MX, SPF, DMARC, and TLS probing

Detects whether an OCI container image tag has materially changed by comparing its current digest and platform state to a previous deterministic hash, without pulling image layers.

Detects material changes in a public product page (price, availability, variant, or seller) using a deterministic SHA-256 hash, excluding noise like timestamps and analytics.

Checks whether a DNS record has fully propagated across multiple public DNS resolvers and reports consensus state

Detects material changes in public DNS records for a given hostname and record type using a deterministic hash, ignoring TTL-only changes.

Detects material changes in a public TLS certificate (fingerprint, issuer, SANs, validity window) by comparing a deterministic hash against a previously stored hash.

Returns a single real-time snapshot of funding and market data for a named Hyperliquid native perpetual, including hourly rate, 8-hour equivalent, simple annualized rate, mark/oracle basis, funding premium index, open interest, daily notional volume, and max leverage.

Resolves a public GitHub repository release into the most appropriate downloadable binary asset for a given OS and architecture target, excluding source archives, signatures, and checksums, and surfacing checksum companions when available.

Validates and normalizes metadata for a specific npm or PyPI package (and optional version), returning existence, version resolution, staleness, deprecation/yank state, license, and runtime requirements.

Fetches a single static HTML page and returns a deduplicated, normalized set of all public HTTP(S) anchor links, classified as same-origin or cross-origin.

Validates email syntax, DNS MX records, and domain quality signals (role, free, disposable) to return a safe-to-attempt deliverability decision without connecting to SMTP.

Performs a bounded HTTP HEAD/GET preflight on a public URL, returning origin status, final URL, redirect chain, response headers, cache validators, and optional SHA256 body hash.

Fetches a static public HTML page and extracts all PDF, CSV, XLS, XLSX, ZIP, JSON, and XML download links, resolving relative URLs and deduplicating results.

Extracts the main article body from a public static HTML page as clean text and conservative Markdown, stripping navigation, footers, forms, and other non-content chrome.

Detects bounded, deterministic changes across a static HTML page by comparing multi-dimensional SHA-256 hashes (HTTP identity, metadata, JSON-LD, links, forms, robots) against a previously captured baseline.

Compares two public OpenAPI/Swagger contracts (before and after URLs) to detect directly observable breaking compatibility changes such as removed operations, newly required fields, narrowed enums, removed content types, and tightened authentication.

Fetches and normalizes a public Atlassian Statuspage into a structured health envelope with operational state, active incidents, scheduled maintenance, and component statuses.

Fingerprints the normalized tools/list schema contract of a public MCP endpoint and detects whether it has materially changed since a previous SHA-256 hash snapshot.

Normalizes a public product URL into current title, selected variant, price, currency, availability, and buyability using read-only provider responses or JSON-LD.

Returns all OS/architecture platform variants declared in an OCI image index or manifest list for a public container image, without downloading any image layers.

Returns the latest official U.S. Treasury Daily Treasury Par Yield Curve Rates snapshot across all standard maturities (1 month to 30 years), with missing tenors reported as null and no interpolation or forecasting.

Normalizes a declared package license string from npm or PyPI toward a canonical SPDX identifier, without making legal compatibility judgments.

Returns normalized security evidence for a single ERC-20 token contract on a supported EVM chain using the GoPlus Token Security API, classifying control, trading-restriction, and tax risk signals.

Fingerprints the structural contract of a public OpenAPI or Swagger spec and detects API contract drift by comparing against an optional previous SHA-256 hash.

Detects material changes to a public HTTP endpoint by comparing bounded response metadata (ETag, Last-Modified, content hash) against a previous hash, without downloading arbitrary response bodies.

Extracts public product identifiers (SKU, GTIN, UPC, EAN, ISBN, MPN, provider IDs) from a product page URL, returning null for any identifier not found rather than guessing.

Validates caller-supplied JSON against the Forest bounded JSON Schema subset v1 and returns deterministic, machine-readable violation reports with stable paths — no network I/O, inference, or mutation.

Lists OCI 1.1 artifacts (such as SBOMs and attestation evidence) that refer to a specific image digest in a public container registry.

Detects material changes to a public GitHub repository by comparing a deterministic hash of existence, branch, and archive state against a previous hash.

Search and discover machine-payable x402 resources by query or URL, returning normalized discovery metadata for each result.

Performs a read-only preflight probe of an x402 PaymentRequired endpoint to inspect its payment requirements without actually executing a payment.

Deterministically hash up to 100 KiB of UTF-8 text with SHA-256 or SHA-512, returning both hexadecimal and Base64 digests with no external network calls.

Encode UTF-8 text to standard or URL-safe Base64, or decode canonical Base64 back to UTF-8 text, with strict size and encoding validation.

Extract a single bounded value from caller-supplied JSON using a deterministic dot-notation path expression, returning the value and an explicit found flag.

Inspects a public MCP HTTP endpoint, auto-detects protocol version, and returns a deterministic SHA-256 contract fingerprint of its tools/list schema without invoking any tools

Deep-compares two JSON values with deterministic key ordering and index-based array semantics, returning bounded added, removed, and changed paths with before/after primitive values.

Checks an Apify Actor's agentic-payment eligibility, pricing/budget signals, and input compatibility before running a paid automation, without starting the Actor or spending credits.

Checks whether a public marketplace item appears purchasable, returning explicit blockers like out-of-stock status without signing in or placing any order.

Detects material changes in a public marketplace listing (active state, price, seller, condition, or quantity) using a deterministic SHA-256 hash comparison.

Resolves and normalizes the availability state of a public product or listing URL, reporting only provider-supplied evidence without inferring inventory or placing any order.

Returns a normalized current offer price for a public product or listing URL, with optional variant scoping, without performing a purchase or requiring authentication.

Returns seller identity and publicly published seller signals (feedback, business fields) for a marketplace listing URL, with missing fields returned as null.

Validates whether a specific product variant can be purchased and shipped to a destination, returning price, availability, and shipping options before committing to a transaction.

Validates whether an isolated cart with a given product URL, variant, and quantity can reach checkout, exposing any blockers without placing an order or processing payment.

Resolves a mutable OCI image tag to its current immutable content digest using the Distribution manifest API, without asserting signature or vulnerability status.

Returns manifest-declared OCI config metadata and individual layer sizes for a public container image before pulling it.

Performs a preflight inspection of a public OCI container image for a specified target platform, returning manifest metadata, config/layer sizes, and referrer presence without downloading any layers.

Resolves a public OCI container image tag to its immutable manifest digest via the standard Distribution API, without pulling blobs or accessing private registries.

Checks the registration status, registrar, and expiry of a domain name without performing unrelated domain checks.

Checks whether a domain is properly configured for email sending and receiving by validating its MX, SPF, and DMARC DNS records — without verifying individual mailboxes.

Measures sequential HTTP response-time samples (up to 3) for a public endpoint, returning bounded timing data without load-testing or port-scanning.

Validates a product item into an isolated, ephemeral commerce session to check purchasability without touching a real cart or initiating payment.

Fetches lightweight metadata (size, type, SHA, existence) for a file path in a public GitHub repository at an optional ref, without cloning or downloading file contents.

Resolves a single public DNS record type (A, AAAA, CNAME, MX, NS, TXT) for a hostname into normalized answers with TTL and authority metadata.

Resolves the current public state of a GitHub repository (archived, fork, branch, license, etc.) using only the public GitHub API — no cloning or OAuth required.

Performs a bounded public HTTP health probe returning status code, redirect chain, content type, and response size for a given URL.

Checks whether a named branch exists in a public GitHub repository and returns its current head commit SHA without cloning.

Queries multiple DNS resolvers in parallel for a given hostname and record type, then returns whether they all agree on the answer (consensus state).

Resolves a public GitHub branch ref to its current commit metadata (SHA, author, timestamp, verification status) without fetching a diff.

Reads and normalizes the latest public GitHub Actions workflow run state for a given repository and workflow, returning a clean status snapshot.

Inspects a public TLS endpoint on port 443 and returns certificate identity fields and validity window facts as a bounded preflight check.

Returns the public TLS certificate validity window and remaining lifetime for a given public hostname on port 443.

Checks whether a public job posting is still open/published and returns its canonical application URL, normalized across Greenhouse, Lever, and Ashby ATS platforms.

Checks whether a specific job posting has been closed or materially changed since a previously recorded hash, returning a lightweight change signal.

Returns a single real-time Coinbase spot price snapshot for a given BASE-QUOTE product pair, including venue price, 24-hour price change, and 24-hour product volume.

Fingerprints the normalized metadata state of a public GitHub release and optionally detects changes by comparing against a caller-provided previous SHA-256 hash.

Returns known vulnerabilities for a specified package and version in npm or PyPI ecosystems, providing normalized evidence without issuing a safety verdict.

Checks whether a GitHub (or similar) repository has a usable latest or tagged release before deployment or download.

Detects whether normalized npm or PyPI package metadata has changed since a saved SHA-256 fingerprint, covering version existence, deprecation, license, and runtime requirements.

Fetches a structured representation of a webpage and detects whether its content has materially changed since a previous snapshot, identified by a SHA-256 hash.

Looks up a specific HTTP method and path in a public OpenAPI/Swagger specification and reports whether that documented endpoint exists in the contract, without invoking the actual API.

Discovers a website's sitemap by reading robots.txt declarations and checking conventional sitemap.xml/sitemap_index.xml locations, returning verified evidence without crawling pages

Resolves a Legal Entity Identifier (LEI) to full GLEIF entity data including legal name, jurisdiction, status, and registration details.

Sends a single CORS OPTIONS preflight request to a public URL and normalizes the Access-Control-Allow-* response into structured origin, method, and header permission decisions.

Fetches and interprets the robots.txt rules for a given URL and user agent, returning crawl permission decisions, matched rules, sitemaps, and crawl delay.

Fetches a public URL and returns structured metadata including title, description, Open Graph tags, JSON-LD entities, robots directives, language, and canonical URL.

Returns the declared request/response contract (parameters, body content types, response statuses, security schemes) for one specific OpenAPI or Swagger operation without executing it or resolving external references.

Returns a bounded current EVM fee-history snapshot (base fee and priority-fee percentiles) for a specified supported chain via SolidRPC public JSON-RPC

Validates a single JSON request or response payload against the documented JSON schema for a specific OpenAPI or Swagger operation path and method.

Performs a bounded static crawl of a public URL to discover machine-usable developer documentation including llms.txt, Markdown alternates, OpenAPI/Swagger specs, and MCP candidates, returning only verified results within 10 HTTP requests.

Verifies whether a given OpenAPI/Swagger document URL is reachable, parseable, and reports its operations, authentication schemes, and servers.

Fetches and extracts all HTML forms from a public URL, returning structured form metadata including field counts and rendering details.

Normalizes public marketplace listing activity, offer, seller, condition, and quantity signals from a given listing URL into a structured state representation.

Fetches and returns structured application form fields and questions for a job posting from supported ATS providers (Greenhouse, Lever, Ashby).

Finds checksum and signature companion assets (e.g. .sha256, .sig files) for a given release asset in a repository.

Decodes an opaque encoded string (JWT, Base64, Base64URL, gzip, hex, Brotli) into readable JSON, text, or binary evidence using deterministic local rules

Validates a requested item quantity against public variant constraints and known availability without reserving or purchasing inventory.

Resolves requested product options (size, color, etc.) to a canonical public variant identifier, explicitly reporting ambiguous or missing options without modifying any cart or checkout state.

Reports public delivery options (shipping methods, rates, availability) for a given product variant, quantity, and destination from a provider's storefront without touching any real cart or order.

Checks whether a given hostname/URL is ready for deployment by inspecting its DNS propagation, TLS certificate, and HTTP reachability status.

Normalizes and extracts explicitly published compensation data from a job listing, without inferring missing salary information.

Returns the current public application URL/route for a job posting without submitting an application

Fetches and returns active service incidents from a given status URL in a normalized, structured form.

Discovers API documentation, developer portals, candidate base URLs, and auth documentation for a given service URL

Performs a read-only MCP handshake and tools-list preflight check against a target MCP server URL, returning protocol compatibility and available tools without executing any destructive calls.

Search for public MCP server candidates and retrieve registry metadata by query and optional registry URL

Resolves a public product URL to its redirect chain, canonical URL, and stable provider identifiers using bounded HTTP and structured data extraction (no JavaScript execution).

Inspects a public URL or OpenAPI endpoint to determine if an API is reachable, parseable, and ready for discovery, returning structured readiness metadata.

Checks whether a remote service's current state has materially changed since a previously recorded canonical hash, acting as a cheap watchdog.

Resolves the live operational state of a named service component by probing a given status URL.