# x402 Eligibility Checker (`junipr/x402-eligibility-checker`) Actor

Check whether an actor/tool configuration appears ready for x402-style agentic payment eligibility by auditing pricing, permissions, standby mode, schema clarity, and event configuration.

- **URL**: https://apify.com/junipr/x402-eligibility-checker.md
- **Developed by:** [junipr](https://apify.com/junipr) (community)
- **Categories:** SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.50 / 1,000 operation testeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## x402 Eligibility Checker

### Store Positioning

**Store title:** x402 Eligibility Checker

**Short description:** Check whether an actor/tool configuration appears ready for x402-style agentic payment eligibility by auditing pricing, permissions, standby mode, schema clarity, and event configuration.

**SEO title:** x402 Eligibility Checker — API, schema, and developer QA

**SEO description:** Check whether an actor/tool configuration appears ready for x402-style agentic payment eligibility by auditing pricing, permissions, standby mode, schema clarity, and event configuration. Use it to catch contract drift, schema mistakes, unsafe endpoint assumptions, and developer-tool quality issues before release.

**Categories:** SEO\_TOOLS, DEVELOPER\_TOOLS

**Keywords:** x402, eligibility, checker, schema, pricing audit, api/developer qa

### Pay-Per-Event Pricing

This actor uses pay-per-event pricing. Event prices include Apify platform usage; users are not expected to pay a separate platform-usage pass-through charge for the configured pricing model.

- Tier: A1 — API/developer QA
- Primary event: `operation-tested` at $0.00650 base
- Default max charge: $10.00
- Store discounts: FREE/BRONZE base, SILVER discounted, GOLD deepest approved discount

Event set:

- `actor-start`: base $0.00500, GOLD $0.00400. X402 Eligibility Checker: charged when actor start is completed. The price includes Apify platform usage; no separate usage pass-through is intended.
- `operation-tested`: base $0.00650, GOLD $0.00520. X402 Eligibility Checker: charged when operation tested is completed. The price includes Apify platform usage; no separate usage pass-through is intended.
- `contract-rule-checked`: base $0.00390, GOLD $0.00312. X402 Eligibility Checker: charged when contract rule checked is completed. The price includes Apify platform usage; no separate usage pass-through is intended.
- `report-generated`: base $0.05000, GOLD $0.04000. X402 Eligibility Checker: charged when report generated is completed. The price includes Apify platform usage; no separate usage pass-through is intended.

The actor accepts `actor-start` before work, accepts the primary event before each dataset row, and accepts `report-generated` before writing report files. If `maxChargeUsd` or the live PPE limit blocks a charge, the corresponding row or report is not written.

### Public Task Concepts

- Audit x402 Eligibility controls on a capped public sample
- Find high-priority x402 Eligibility issues before release
- Validate x402 Eligibility evidence from supplied pages
- Prioritize x402 Eligibility fixes with severity and proof
- Export x402 Eligibility QA rows for client review
  Audit actor metadata for x402-style agentic payment readiness.

### What It Does

Checks PPE pricing, Standby usage, broad permissions, schema clarity, README readiness, and public task availability.

### Inputs

This actor exposes these input fields in `.actor/input_schema.json`:

- `actorConfigJson`
- `actorMetadataJson`
- `pricingConfigJson`
- `readmeText`
- `inputSchemaJson`
- `datasetSchemaJson`
- `strictMode`
- `maxChargeUsd`

The exact default audits the real local public configuration, pricing, README, input schema, dataset schema, and five task definitions for `openapi-response-validator` at the current committed source tip; it contains no credentials.

### Outputs

Dataset rows contain:

- `actorSlug`
- `checkName`
- `checkStatus`
- `requirementCategory`
- `evidence`
- `severity`
- `fixHint`
- `eligibilityImpact`
- `overallEligibility`

Sample outputs in `examples/output.sample.json` and `output.sample.json` were generated from `examples/input.tiny.json` through actor logic.

### Reports

After the `report-generated` charge is accepted, the actor writes its Markdown, JSON, or CSV reports to the key-value store. A rejected report charge leaves those files unwritten.

### Public Task Concepts

- Validate x402 Eligibility Checker before release
- Run a bounded x402 Eligibility Checker QA check
- Generate developer QA evidence for x402 Eligibility Checker

### Safe use

Use small capped runs first. Network paths are bounded; review output quality and costs before increasing limits.

# Actor input Schema

## `actorConfigJson` (type: `object`):

Inline actor config JSON object used by x402 Eligibility Checker.

## `actorMetadataJson` (type: `object`):

Inline actor metadata JSON object used by x402 Eligibility Checker.

## `pricingConfigJson` (type: `object`):

Inline pricing config JSON object used by x402 Eligibility Checker.

## `readmeText` (type: `string`):

Supplied readme text to analyze directly.

## `inputSchemaJson` (type: `object`):

Inline input schema JSON object used by x402 Eligibility Checker.

## `datasetSchemaJson` (type: `object`):

Inline dataset schema JSON object used by x402 Eligibility Checker.

## `strictMode` (type: `boolean`):

Strict Mode controlling how x402 Eligibility Checker processes the supplied inputs.

## `maxChargeUsd` (type: `number`):

Maximum estimated PPE charge allowed for the run before the actor stops gracefully.

## Actor input object example

```json
{
  "actorConfigJson": {
    "actorSpecification": 1,
    "name": "openapi-response-validator",
    "version": "1.0",
    "meta": {
      "templateId": "node-js",
      "categories": [
        "SEO_TOOLS",
        "DEVELOPER_TOOLS",
        "ECOMMERCE"
      ],
      "seoTitle": "OpenAPI Response Validator — API, schema, and developer QA",
      "seoDescription": "Validate live or supplied API responses against an OpenAPI operation’s expected response schema and return endpoint-level pass/fail evidence. Use it to catch contract drift, schema mistakes, unsafe endpoint assumptions, and developer-tool quality issues before release.",
      "keywords": [
        "openapi",
        "response",
        "validator",
        "schema",
        "api testing",
        "api/developer qa"
      ]
    },
    "input": "./input_schema.json",
    "dockerfile": "../Dockerfile",
    "defaultMemoryMbytes": 512,
    "minMemoryMbytes": 128,
    "maxMemoryMbytes": 1024,
    "categories": [
      "SEO_TOOLS",
      "DEVELOPER_TOOLS",
      "ECOMMERCE"
    ],
    "permissions": []
  },
  "actorMetadataJson": {
    "actorSlug": "openapi-response-validator",
    "publicTasks": [
      {
        "taskSlug": "openapi-response-validator-validate-valid-response",
        "taskTitle": "Validate a valid OpenAPI response",
        "taskSeoTitle": "Validate a valid OpenAPI response | OpenAPI Response Validator",
        "taskSeoDescription": "Validate a response body that satisfies its operation status schema, including required fields and enum values.",
        "taskUseCaseKeyword": "validate a valid openapi response",
        "taskInputJson": {
          "openapiSpecJson": {
            "openapi": "3.0.3",
            "info": {
              "version": "1.0.0"
            },
            "components": {
              "schemas": {
                "User": {
                  "type": "object",
                  "required": [
                    "id",
                    "email"
                  ],
                  "properties": {
                    "id": {
                      "type": "string",
                      "title": "Id",
                      "description": "Id input value."
                    },
                    "email": {
                      "type": "string",
                      "title": "Email",
                      "description": "Email input value."
                    },
                    "role": {
                      "type": "string",
                      "enum": [
                        "admin",
                        "member"
                      ],
                      "title": "Role",
                      "description": "Role input value."
                    },
                    "nickname": {
                      "type": "string",
                      "nullable": true,
                      "title": "Nickname",
                      "description": "Nickname input value."
                    }
                  }
                },
                "Error": {
                  "type": "object",
                  "required": [
                    "code"
                  ],
                  "properties": {
                    "code": {
                      "type": "string",
                      "title": "Code",
                      "description": "Code input value."
                    },
                    "message": {
                      "type": "string",
                      "title": "Message",
                      "description": "Message input value."
                    }
                  }
                }
              },
              "securitySchemes": {
                "ApiKeyAuth": {
                  "type": "apiKey",
                  "in": "header",
                  "name": "X-API-Key"
                },
                "BearerAuth": {
                  "type": "http",
                  "scheme": "bearer"
                }
              }
            },
            "security": [
              {
                "ApiKeyAuth": []
              }
            ],
            "paths": {
              "/users/{id}": {
                "get": {
                  "operationId": "getUser",
                  "security": [
                    {
                      "ApiKeyAuth": []
                    }
                  ],
                  "responses": {
                    "200": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/User"
                          }
                        }
                      }
                    },
                    "404": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/Error"
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/orders": {
                "post": {
                  "operationId": "createOrder",
                  "security": [
                    {
                      "BearerAuth": []
                    }
                  ],
                  "responses": {
                    "201": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "type": "object",
                            "required": [
                              "orderId"
                            ],
                            "properties": {
                              "orderId": {
                                "type": "string",
                                "title": "Order Id",
                                "description": "Order Id input value."
                              },
                              "total": {
                                "type": "number",
                                "title": "Total",
                                "description": "Total input value."
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/status": {
                "get": {
                  "operationId": "getStatus",
                  "security": [],
                  "responses": {
                    "200": {}
                  }
                }
              }
            }
          },
          "operationIds": [
            "getUser"
          ],
          "responseSamples": [
            {
              "operationId": "getUser",
              "method": "GET",
              "path": "/users/{id}",
              "statusCode": 200,
              "body": {
                "id": "u_1",
                "email": "a@example.com",
                "role": "admin",
                "nickname": null
              }
            }
          ],
          "allowedMethods": [
            "GET"
          ],
          "skipUnsafeMethods": true,
          "maxOperations": 10,
          "maxChargeUsd": 1
        },
        "taskDatasetView": "default",
        "taskExpectedOutputSummary": "Valid response row with schemaFound=true and responseValid=true.",
        "taskSafetyNotes": "Uses a small capped public or user-supplied input. Do not include secrets, private credentials, or restricted data.",
        "name": "openapi-response-validator-validate-valid-response",
        "searchIntent": "Validate a valid OpenAPI response",
        "input": {
          "openapiSpecJson": {
            "openapi": "3.0.3",
            "info": {
              "version": "1.0.0"
            },
            "components": {
              "schemas": {
                "User": {
                  "type": "object",
                  "required": [
                    "id",
                    "email"
                  ],
                  "properties": {
                    "id": {
                      "type": "string",
                      "title": "Id",
                      "description": "Id input value."
                    },
                    "email": {
                      "type": "string",
                      "title": "Email",
                      "description": "Email input value."
                    },
                    "role": {
                      "type": "string",
                      "enum": [
                        "admin",
                        "member"
                      ],
                      "title": "Role",
                      "description": "Role input value."
                    },
                    "nickname": {
                      "type": "string",
                      "nullable": true,
                      "title": "Nickname",
                      "description": "Nickname input value."
                    }
                  }
                },
                "Error": {
                  "type": "object",
                  "required": [
                    "code"
                  ],
                  "properties": {
                    "code": {
                      "type": "string",
                      "title": "Code",
                      "description": "Code input value."
                    },
                    "message": {
                      "type": "string",
                      "title": "Message",
                      "description": "Message input value."
                    }
                  }
                }
              },
              "securitySchemes": {
                "ApiKeyAuth": {
                  "type": "apiKey",
                  "in": "header",
                  "name": "X-API-Key"
                },
                "BearerAuth": {
                  "type": "http",
                  "scheme": "bearer"
                }
              }
            },
            "security": [
              {
                "ApiKeyAuth": []
              }
            ],
            "paths": {
              "/users/{id}": {
                "get": {
                  "operationId": "getUser",
                  "security": [
                    {
                      "ApiKeyAuth": []
                    }
                  ],
                  "responses": {
                    "200": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/User"
                          }
                        }
                      }
                    },
                    "404": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/Error"
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/orders": {
                "post": {
                  "operationId": "createOrder",
                  "security": [
                    {
                      "BearerAuth": []
                    }
                  ],
                  "responses": {
                    "201": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "type": "object",
                            "required": [
                              "orderId"
                            ],
                            "properties": {
                              "orderId": {
                                "type": "string",
                                "title": "Order Id",
                                "description": "Order Id input value."
                              },
                              "total": {
                                "type": "number",
                                "title": "Total",
                                "description": "Total input value."
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/status": {
                "get": {
                  "operationId": "getStatus",
                  "security": [],
                  "responses": {
                    "200": {}
                  }
                }
              }
            }
          },
          "operationIds": [
            "getUser"
          ],
          "responseSamples": [
            {
              "operationId": "getUser",
              "method": "GET",
              "path": "/users/{id}",
              "statusCode": 200,
              "body": {
                "id": "u_1",
                "email": "a@example.com",
                "role": "admin",
                "nickname": null
              }
            }
          ],
          "allowedMethods": [
            "GET"
          ],
          "skipUnsafeMethods": true,
          "maxOperations": 10,
          "maxChargeUsd": 1
        },
        "expectedOutput": "Valid response row with schemaFound=true and responseValid=true.",
        "whySomeoneWouldRunIt": "Validate a response body that satisfies its operation status schema, including required fields and enum values."
      },
      {
        "taskSlug": "openapi-response-validator-find-missing-required-field",
        "taskTitle": "Find a missing required response field",
        "taskSeoTitle": "Find a missing required response field | OpenAPI Response Validator",
        "taskSeoDescription": "Reproduce a response contract failure caused by a missing required field and return its exact JSON path.",
        "taskUseCaseKeyword": "find a missing required response field",
        "taskInputJson": {
          "openapiSpecJson": {
            "openapi": "3.0.3",
            "info": {
              "version": "1.0.0"
            },
            "components": {
              "schemas": {
                "User": {
                  "type": "object",
                  "required": [
                    "id",
                    "email"
                  ],
                  "properties": {
                    "id": {
                      "type": "string",
                      "title": "Id",
                      "description": "Id input value."
                    },
                    "email": {
                      "type": "string",
                      "title": "Email",
                      "description": "Email input value."
                    },
                    "role": {
                      "type": "string",
                      "enum": [
                        "admin",
                        "member"
                      ],
                      "title": "Role",
                      "description": "Role input value."
                    },
                    "nickname": {
                      "type": "string",
                      "nullable": true,
                      "title": "Nickname",
                      "description": "Nickname input value."
                    }
                  }
                },
                "Error": {
                  "type": "object",
                  "required": [
                    "code"
                  ],
                  "properties": {
                    "code": {
                      "type": "string",
                      "title": "Code",
                      "description": "Code input value."
                    },
                    "message": {
                      "type": "string",
                      "title": "Message",
                      "description": "Message input value."
                    }
                  }
                }
              },
              "securitySchemes": {
                "ApiKeyAuth": {
                  "type": "apiKey",
                  "in": "header",
                  "name": "X-API-Key"
                },
                "BearerAuth": {
                  "type": "http",
                  "scheme": "bearer"
                }
              }
            },
            "security": [
              {
                "ApiKeyAuth": []
              }
            ],
            "paths": {
              "/users/{id}": {
                "get": {
                  "operationId": "getUser",
                  "security": [
                    {
                      "ApiKeyAuth": []
                    }
                  ],
                  "responses": {
                    "200": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/User"
                          }
                        }
                      }
                    },
                    "404": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/Error"
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/orders": {
                "post": {
                  "operationId": "createOrder",
                  "security": [
                    {
                      "BearerAuth": []
                    }
                  ],
                  "responses": {
                    "201": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "type": "object",
                            "required": [
                              "orderId"
                            ],
                            "properties": {
                              "orderId": {
                                "type": "string",
                                "title": "Order Id",
                                "description": "Order Id input value."
                              },
                              "total": {
                                "type": "number",
                                "title": "Total",
                                "description": "Total input value."
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/status": {
                "get": {
                  "operationId": "getStatus",
                  "security": [],
                  "responses": {
                    "200": {}
                  }
                }
              }
            }
          },
          "operationIds": [
            "getUser"
          ],
          "responseSamples": [
            {
              "operationId": "getUser",
              "method": "GET",
              "path": "/users/{id}",
              "statusCode": 200,
              "body": {
                "id": "u_2",
                "role": "member"
              }
            }
          ],
          "allowedMethods": [
            "GET"
          ],
          "maxChargeUsd": 1.02
        },
        "taskDatasetView": "default",
        "taskExpectedOutputSummary": "Invalid response row naming the required-field failure and remediation.",
        "taskSafetyNotes": "Uses a small capped public or user-supplied input. Do not include secrets, private credentials, or restricted data.",
        "name": "openapi-response-validator-find-missing-required-field",
        "searchIntent": "Find a missing required response field",
        "input": {
          "openapiSpecJson": {
            "openapi": "3.0.3",
            "info": {
              "version": "1.0.0"
            },
            "components": {
              "schemas": {
                "User": {
                  "type": "object",
                  "required": [
                    "id",
                    "email"
                  ],
                  "properties": {
                    "id": {
                      "type": "string",
                      "title": "Id",
                      "description": "Id input value."
                    },
                    "email": {
                      "type": "string",
                      "title": "Email",
                      "description": "Email input value."
                    },
                    "role": {
                      "type": "string",
                      "enum": [
                        "admin",
                        "member"
                      ],
                      "title": "Role",
                      "description": "Role input value."
                    },
                    "nickname": {
                      "type": "string",
                      "nullable": true,
                      "title": "Nickname",
                      "description": "Nickname input value."
                    }
                  }
                },
                "Error": {
                  "type": "object",
                  "required": [
                    "code"
                  ],
                  "properties": {
                    "code": {
                      "type": "string",
                      "title": "Code",
                      "description": "Code input value."
                    },
                    "message": {
                      "type": "string",
                      "title": "Message",
                      "description": "Message input value."
                    }
                  }
                }
              },
              "securitySchemes": {
                "ApiKeyAuth": {
                  "type": "apiKey",
                  "in": "header",
                  "name": "X-API-Key"
                },
                "BearerAuth": {
                  "type": "http",
                  "scheme": "bearer"
                }
              }
            },
            "security": [
              {
                "ApiKeyAuth": []
              }
            ],
            "paths": {
              "/users/{id}": {
                "get": {
                  "operationId": "getUser",
                  "security": [
                    {
                      "ApiKeyAuth": []
                    }
                  ],
                  "responses": {
                    "200": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/User"
                          }
                        }
                      }
                    },
                    "404": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/Error"
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/orders": {
                "post": {
                  "operationId": "createOrder",
                  "security": [
                    {
                      "BearerAuth": []
                    }
                  ],
                  "responses": {
                    "201": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "type": "object",
                            "required": [
                              "orderId"
                            ],
                            "properties": {
                              "orderId": {
                                "type": "string",
                                "title": "Order Id",
                                "description": "Order Id input value."
                              },
                              "total": {
                                "type": "number",
                                "title": "Total",
                                "description": "Total input value."
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/status": {
                "get": {
                  "operationId": "getStatus",
                  "security": [],
                  "responses": {
                    "200": {}
                  }
                }
              }
            }
          },
          "operationIds": [
            "getUser"
          ],
          "responseSamples": [
            {
              "operationId": "getUser",
              "method": "GET",
              "path": "/users/{id}",
              "statusCode": 200,
              "body": {
                "id": "u_2",
                "role": "member"
              }
            }
          ],
          "allowedMethods": [
            "GET"
          ],
          "maxChargeUsd": 1.02
        },
        "expectedOutput": "Invalid response row naming the required-field failure and remediation.",
        "whySomeoneWouldRunIt": "Reproduce a response contract failure caused by a missing required field and return its exact JSON path."
      },
      {
        "taskSlug": "openapi-response-validator-detect-type-and-enum-conflict",
        "taskTitle": "Detect a response contract conflict",
        "taskSeoTitle": "Detect a response contract conflict | OpenAPI Response Validator",
        "taskSeoDescription": "Check conflicting response samples for type or enum drift against the supplied OpenAPI schema.",
        "taskUseCaseKeyword": "detect a response contract conflict",
        "taskInputJson": {
          "openapiSpecJson": {
            "openapi": "3.0.3",
            "info": {
              "version": "1.0.0"
            },
            "components": {
              "schemas": {
                "User": {
                  "type": "object",
                  "required": [
                    "id",
                    "email"
                  ],
                  "properties": {
                    "id": {
                      "type": "string",
                      "title": "Id",
                      "description": "Id input value."
                    },
                    "email": {
                      "type": "string",
                      "title": "Email",
                      "description": "Email input value."
                    },
                    "role": {
                      "type": "string",
                      "enum": [
                        "admin",
                        "member"
                      ],
                      "title": "Role",
                      "description": "Role input value."
                    },
                    "nickname": {
                      "type": "string",
                      "nullable": true,
                      "title": "Nickname",
                      "description": "Nickname input value."
                    }
                  }
                },
                "Error": {
                  "type": "object",
                  "required": [
                    "code"
                  ],
                  "properties": {
                    "code": {
                      "type": "string",
                      "title": "Code",
                      "description": "Code input value."
                    },
                    "message": {
                      "type": "string",
                      "title": "Message",
                      "description": "Message input value."
                    }
                  }
                }
              },
              "securitySchemes": {
                "ApiKeyAuth": {
                  "type": "apiKey",
                  "in": "header",
                  "name": "X-API-Key"
                },
                "BearerAuth": {
                  "type": "http",
                  "scheme": "bearer"
                }
              }
            },
            "security": [
              {
                "ApiKeyAuth": []
              }
            ],
            "paths": {
              "/users/{id}": {
                "get": {
                  "operationId": "getUser",
                  "security": [
                    {
                      "ApiKeyAuth": []
                    }
                  ],
                  "responses": {
                    "200": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/User"
                          }
                        }
                      }
                    },
                    "404": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/Error"
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/orders": {
                "post": {
                  "operationId": "createOrder",
                  "security": [
                    {
                      "BearerAuth": []
                    }
                  ],
                  "responses": {
                    "201": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "type": "object",
                            "required": [
                              "orderId"
                            ],
                            "properties": {
                              "orderId": {
                                "type": "string",
                                "title": "Order Id",
                                "description": "Order Id input value."
                              },
                              "total": {
                                "type": "number",
                                "title": "Total",
                                "description": "Total input value."
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/status": {
                "get": {
                  "operationId": "getStatus",
                  "security": [],
                  "responses": {
                    "200": {}
                  }
                }
              }
            }
          },
          "operationIds": [
            "getUser"
          ],
          "responseSamples": [
            {
              "operationId": "getUser",
              "method": "GET",
              "path": "/users/{id}",
              "statusCode": 200,
              "body": {
                "id": "u_3",
                "email": "c@example.com",
                "role": "owner"
              }
            }
          ],
          "allowedMethods": [
            "GET"
          ],
          "maxChargeUsd": 1.03
        },
        "taskDatasetView": "default",
        "taskExpectedOutputSummary": "Endpoint-level contract conflict evidence with expected and actual values.",
        "taskSafetyNotes": "Uses a small capped public or user-supplied input. Do not include secrets, private credentials, or restricted data.",
        "name": "openapi-response-validator-detect-type-and-enum-conflict",
        "searchIntent": "Detect a response contract conflict",
        "input": {
          "openapiSpecJson": {
            "openapi": "3.0.3",
            "info": {
              "version": "1.0.0"
            },
            "components": {
              "schemas": {
                "User": {
                  "type": "object",
                  "required": [
                    "id",
                    "email"
                  ],
                  "properties": {
                    "id": {
                      "type": "string",
                      "title": "Id",
                      "description": "Id input value."
                    },
                    "email": {
                      "type": "string",
                      "title": "Email",
                      "description": "Email input value."
                    },
                    "role": {
                      "type": "string",
                      "enum": [
                        "admin",
                        "member"
                      ],
                      "title": "Role",
                      "description": "Role input value."
                    },
                    "nickname": {
                      "type": "string",
                      "nullable": true,
                      "title": "Nickname",
                      "description": "Nickname input value."
                    }
                  }
                },
                "Error": {
                  "type": "object",
                  "required": [
                    "code"
                  ],
                  "properties": {
                    "code": {
                      "type": "string",
                      "title": "Code",
                      "description": "Code input value."
                    },
                    "message": {
                      "type": "string",
                      "title": "Message",
                      "description": "Message input value."
                    }
                  }
                }
              },
              "securitySchemes": {
                "ApiKeyAuth": {
                  "type": "apiKey",
                  "in": "header",
                  "name": "X-API-Key"
                },
                "BearerAuth": {
                  "type": "http",
                  "scheme": "bearer"
                }
              }
            },
            "security": [
              {
                "ApiKeyAuth": []
              }
            ],
            "paths": {
              "/users/{id}": {
                "get": {
                  "operationId": "getUser",
                  "security": [
                    {
                      "ApiKeyAuth": []
                    }
                  ],
                  "responses": {
                    "200": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/User"
                          }
                        }
                      }
                    },
                    "404": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/Error"
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/orders": {
                "post": {
                  "operationId": "createOrder",
                  "security": [
                    {
                      "BearerAuth": []
                    }
                  ],
                  "responses": {
                    "201": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "type": "object",
                            "required": [
                              "orderId"
                            ],
                            "properties": {
                              "orderId": {
                                "type": "string",
                                "title": "Order Id",
                                "description": "Order Id input value."
                              },
                              "total": {
                                "type": "number",
                                "title": "Total",
                                "description": "Total input value."
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/status": {
                "get": {
                  "operationId": "getStatus",
                  "security": [],
                  "responses": {
                    "200": {}
                  }
                }
              }
            }
          },
          "operationIds": [
            "getUser"
          ],
          "responseSamples": [
            {
              "operationId": "getUser",
              "method": "GET",
              "path": "/users/{id}",
              "statusCode": 200,
              "body": {
                "id": "u_3",
                "email": "c@example.com",
                "role": "owner"
              }
            }
          ],
          "allowedMethods": [
            "GET"
          ],
          "maxChargeUsd": 1.03
        },
        "expectedOutput": "Endpoint-level contract conflict evidence with expected and actual values.",
        "whySomeoneWouldRunIt": "Check conflicting response samples for type or enum drift against the supplied OpenAPI schema."
      },
      {
        "taskSlug": "openapi-response-validator-check-capped-response-batch",
        "taskTitle": "Check a capped OpenAPI response batch",
        "taskSeoTitle": "Check a capped OpenAPI response batch | OpenAPI Response Validator",
        "taskSeoDescription": "Validate a bounded set of response samples while proving maxOperations limits the work performed.",
        "taskUseCaseKeyword": "check a capped openapi response batch",
        "taskInputJson": {
          "openapiSpecJson": {
            "openapi": "3.0.3",
            "info": {
              "version": "1.0.0"
            },
            "components": {
              "schemas": {
                "User": {
                  "type": "object",
                  "required": [
                    "id",
                    "email"
                  ],
                  "properties": {
                    "id": {
                      "type": "string",
                      "title": "Id",
                      "description": "Id input value."
                    },
                    "email": {
                      "type": "string",
                      "title": "Email",
                      "description": "Email input value."
                    },
                    "role": {
                      "type": "string",
                      "enum": [
                        "admin",
                        "member"
                      ],
                      "title": "Role",
                      "description": "Role input value."
                    },
                    "nickname": {
                      "type": "string",
                      "nullable": true,
                      "title": "Nickname",
                      "description": "Nickname input value."
                    }
                  }
                },
                "Error": {
                  "type": "object",
                  "required": [
                    "code"
                  ],
                  "properties": {
                    "code": {
                      "type": "string",
                      "title": "Code",
                      "description": "Code input value."
                    },
                    "message": {
                      "type": "string",
                      "title": "Message",
                      "description": "Message input value."
                    }
                  }
                }
              },
              "securitySchemes": {
                "ApiKeyAuth": {
                  "type": "apiKey",
                  "in": "header",
                  "name": "X-API-Key"
                },
                "BearerAuth": {
                  "type": "http",
                  "scheme": "bearer"
                }
              }
            },
            "security": [
              {
                "ApiKeyAuth": []
              }
            ],
            "paths": {
              "/users/{id}": {
                "get": {
                  "operationId": "getUser",
                  "security": [
                    {
                      "ApiKeyAuth": []
                    }
                  ],
                  "responses": {
                    "200": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/User"
                          }
                        }
                      }
                    },
                    "404": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/Error"
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/orders": {
                "post": {
                  "operationId": "createOrder",
                  "security": [
                    {
                      "BearerAuth": []
                    }
                  ],
                  "responses": {
                    "201": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "type": "object",
                            "required": [
                              "orderId"
                            ],
                            "properties": {
                              "orderId": {
                                "type": "string",
                                "title": "Order Id",
                                "description": "Order Id input value."
                              },
                              "total": {
                                "type": "number",
                                "title": "Total",
                                "description": "Total input value."
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/status": {
                "get": {
                  "operationId": "getStatus",
                  "security": [],
                  "responses": {
                    "200": {}
                  }
                }
              }
            }
          },
          "responseSamples": [
            {
              "operationId": "getUser",
              "method": "GET",
              "path": "/users/{id}",
              "statusCode": 200,
              "body": {
                "id": "u_4",
                "email": "d@example.com"
              }
            },
            {
              "operationId": "getUser",
              "method": "GET",
              "path": "/users/{id}",
              "statusCode": 200,
              "body": {
                "id": "u_5",
                "email": "e@example.com"
              }
            }
          ],
          "allowedMethods": [
            "GET"
          ],
          "maxOperations": 1,
          "maxChargeUsd": 1.04
        },
        "taskDatasetView": "default",
        "taskExpectedOutputSummary": "Capped response validation rows plus a charged summary report.",
        "taskSafetyNotes": "Uses a small capped public or user-supplied input. Do not include secrets, private credentials, or restricted data.",
        "name": "openapi-response-validator-check-capped-response-batch",
        "searchIntent": "Check a capped OpenAPI response batch",
        "input": {
          "openapiSpecJson": {
            "openapi": "3.0.3",
            "info": {
              "version": "1.0.0"
            },
            "components": {
              "schemas": {
                "User": {
                  "type": "object",
                  "required": [
                    "id",
                    "email"
                  ],
                  "properties": {
                    "id": {
                      "type": "string",
                      "title": "Id",
                      "description": "Id input value."
                    },
                    "email": {
                      "type": "string",
                      "title": "Email",
                      "description": "Email input value."
                    },
                    "role": {
                      "type": "string",
                      "enum": [
                        "admin",
                        "member"
                      ],
                      "title": "Role",
                      "description": "Role input value."
                    },
                    "nickname": {
                      "type": "string",
                      "nullable": true,
                      "title": "Nickname",
                      "description": "Nickname input value."
                    }
                  }
                },
                "Error": {
                  "type": "object",
                  "required": [
                    "code"
                  ],
                  "properties": {
                    "code": {
                      "type": "string",
                      "title": "Code",
                      "description": "Code input value."
                    },
                    "message": {
                      "type": "string",
                      "title": "Message",
                      "description": "Message input value."
                    }
                  }
                }
              },
              "securitySchemes": {
                "ApiKeyAuth": {
                  "type": "apiKey",
                  "in": "header",
                  "name": "X-API-Key"
                },
                "BearerAuth": {
                  "type": "http",
                  "scheme": "bearer"
                }
              }
            },
            "security": [
              {
                "ApiKeyAuth": []
              }
            ],
            "paths": {
              "/users/{id}": {
                "get": {
                  "operationId": "getUser",
                  "security": [
                    {
                      "ApiKeyAuth": []
                    }
                  ],
                  "responses": {
                    "200": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/User"
                          }
                        }
                      }
                    },
                    "404": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/Error"
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/orders": {
                "post": {
                  "operationId": "createOrder",
                  "security": [
                    {
                      "BearerAuth": []
                    }
                  ],
                  "responses": {
                    "201": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "type": "object",
                            "required": [
                              "orderId"
                            ],
                            "properties": {
                              "orderId": {
                                "type": "string",
                                "title": "Order Id",
                                "description": "Order Id input value."
                              },
                              "total": {
                                "type": "number",
                                "title": "Total",
                                "description": "Total input value."
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/status": {
                "get": {
                  "operationId": "getStatus",
                  "security": [],
                  "responses": {
                    "200": {}
                  }
                }
              }
            }
          },
          "responseSamples": [
            {
              "operationId": "getUser",
              "method": "GET",
              "path": "/users/{id}",
              "statusCode": 200,
              "body": {
                "id": "u_4",
                "email": "d@example.com"
              }
            },
            {
              "operationId": "getUser",
              "method": "GET",
              "path": "/users/{id}",
              "statusCode": 200,
              "body": {
                "id": "u_5",
                "email": "e@example.com"
              }
            }
          ],
          "allowedMethods": [
            "GET"
          ],
          "maxOperations": 1,
          "maxChargeUsd": 1.04
        },
        "expectedOutput": "Capped response validation rows plus a charged summary report.",
        "whySomeoneWouldRunIt": "Validate a bounded set of response samples while proving maxOperations limits the work performed."
      },
      {
        "taskSlug": "openapi-response-validator-export-missing-schema-evidence",
        "taskTitle": "Export missing response schema evidence",
        "taskSeoTitle": "Export missing response schema evidence | OpenAPI Response Validator",
        "taskSeoDescription": "Identify an operation or status code whose OpenAPI response does not define a usable JSON schema.",
        "taskUseCaseKeyword": "export missing response schema evidence",
        "taskInputJson": {
          "openapiSpecJson": {
            "openapi": "3.0.3",
            "info": {
              "version": "1.0.0"
            },
            "components": {
              "schemas": {
                "User": {
                  "type": "object",
                  "required": [
                    "id",
                    "email"
                  ],
                  "properties": {
                    "id": {
                      "type": "string",
                      "title": "Id",
                      "description": "Id input value."
                    },
                    "email": {
                      "type": "string",
                      "title": "Email",
                      "description": "Email input value."
                    },
                    "role": {
                      "type": "string",
                      "enum": [
                        "admin",
                        "member"
                      ],
                      "title": "Role",
                      "description": "Role input value."
                    },
                    "nickname": {
                      "type": "string",
                      "nullable": true,
                      "title": "Nickname",
                      "description": "Nickname input value."
                    }
                  }
                },
                "Error": {
                  "type": "object",
                  "required": [
                    "code"
                  ],
                  "properties": {
                    "code": {
                      "type": "string",
                      "title": "Code",
                      "description": "Code input value."
                    },
                    "message": {
                      "type": "string",
                      "title": "Message",
                      "description": "Message input value."
                    }
                  }
                }
              },
              "securitySchemes": {
                "ApiKeyAuth": {
                  "type": "apiKey",
                  "in": "header",
                  "name": "X-API-Key"
                },
                "BearerAuth": {
                  "type": "http",
                  "scheme": "bearer"
                }
              }
            },
            "security": [
              {
                "ApiKeyAuth": []
              }
            ],
            "paths": {
              "/users/{id}": {
                "get": {
                  "operationId": "getUser",
                  "security": [
                    {
                      "ApiKeyAuth": []
                    }
                  ],
                  "responses": {
                    "200": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/User"
                          }
                        }
                      }
                    },
                    "404": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/Error"
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/orders": {
                "post": {
                  "operationId": "createOrder",
                  "security": [
                    {
                      "BearerAuth": []
                    }
                  ],
                  "responses": {
                    "201": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "type": "object",
                            "required": [
                              "orderId"
                            ],
                            "properties": {
                              "orderId": {
                                "type": "string",
                                "title": "Order Id",
                                "description": "Order Id input value."
                              },
                              "total": {
                                "type": "number",
                                "title": "Total",
                                "description": "Total input value."
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/status": {
                "get": {
                  "operationId": "getStatus",
                  "security": [],
                  "responses": {
                    "200": {}
                  }
                }
              }
            }
          },
          "responseSamples": [
            {
              "operationId": "getStatus",
              "method": "GET",
              "path": "/status",
              "statusCode": 200,
              "body": {
                "ok": true
              }
            }
          ],
          "allowedMethods": [
            "GET"
          ],
          "maxChargeUsd": 1.05
        },
        "taskDatasetView": "default",
        "taskExpectedOutputSummary": "Missing-schema row with operation, status, and recommended fix.",
        "taskSafetyNotes": "Uses a small capped public or user-supplied input. Do not include secrets, private credentials, or restricted data.",
        "name": "openapi-response-validator-export-missing-schema-evidence",
        "searchIntent": "Export missing response schema evidence",
        "input": {
          "openapiSpecJson": {
            "openapi": "3.0.3",
            "info": {
              "version": "1.0.0"
            },
            "components": {
              "schemas": {
                "User": {
                  "type": "object",
                  "required": [
                    "id",
                    "email"
                  ],
                  "properties": {
                    "id": {
                      "type": "string",
                      "title": "Id",
                      "description": "Id input value."
                    },
                    "email": {
                      "type": "string",
                      "title": "Email",
                      "description": "Email input value."
                    },
                    "role": {
                      "type": "string",
                      "enum": [
                        "admin",
                        "member"
                      ],
                      "title": "Role",
                      "description": "Role input value."
                    },
                    "nickname": {
                      "type": "string",
                      "nullable": true,
                      "title": "Nickname",
                      "description": "Nickname input value."
                    }
                  }
                },
                "Error": {
                  "type": "object",
                  "required": [
                    "code"
                  ],
                  "properties": {
                    "code": {
                      "type": "string",
                      "title": "Code",
                      "description": "Code input value."
                    },
                    "message": {
                      "type": "string",
                      "title": "Message",
                      "description": "Message input value."
                    }
                  }
                }
              },
              "securitySchemes": {
                "ApiKeyAuth": {
                  "type": "apiKey",
                  "in": "header",
                  "name": "X-API-Key"
                },
                "BearerAuth": {
                  "type": "http",
                  "scheme": "bearer"
                }
              }
            },
            "security": [
              {
                "ApiKeyAuth": []
              }
            ],
            "paths": {
              "/users/{id}": {
                "get": {
                  "operationId": "getUser",
                  "security": [
                    {
                      "ApiKeyAuth": []
                    }
                  ],
                  "responses": {
                    "200": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/User"
                          }
                        }
                      }
                    },
                    "404": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "$ref": "#/components/schemas/Error"
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/orders": {
                "post": {
                  "operationId": "createOrder",
                  "security": [
                    {
                      "BearerAuth": []
                    }
                  ],
                  "responses": {
                    "201": {
                      "content": {
                        "application/json": {
                          "schema": {
                            "type": "object",
                            "required": [
                              "orderId"
                            ],
                            "properties": {
                              "orderId": {
                                "type": "string",
                                "title": "Order Id",
                                "description": "Order Id input value."
                              },
                              "total": {
                                "type": "number",
                                "title": "Total",
                                "description": "Total input value."
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              },
              "/status": {
                "get": {
                  "operationId": "getStatus",
                  "security": [],
                  "responses": {
                    "200": {}
                  }
                }
              }
            }
          },
          "responseSamples": [
            {
              "operationId": "getStatus",
              "method": "GET",
              "path": "/status",
              "statusCode": 200,
              "body": {
                "ok": true
              }
            }
          ],
          "allowedMethods": [
            "GET"
          ],
          "maxChargeUsd": 1.05
        },
        "expectedOutput": "Missing-schema row with operation, status, and recommended fix.",
        "whySomeoneWouldRunIt": "Identify an operation or status code whose OpenAPI response does not define a usable JSON schema."
      }
    ]
  },
  "pricingConfigJson": {
    "model": "PPE",
    "events": {
      "actor-start": {
        "unitUsd": 0.005,
        "eventPriceUsd": 0.005,
        "tierPricesUsd": {
          "FREE": 0.005,
          "BRONZE": 0.005,
          "SILVER": 0.0045,
          "GOLD": 0.004
        },
        "chargedBeforeOutput": true,
        "eventTitle": "Openapi Response Validator Actor Start",
        "eventDescription": "Openapi Response Validator: charged when actor start is completed. The price includes Apify platform usage; no separate usage pass-through is intended.",
        "triggeringCondition": "Charged before paid dataset output or the corresponding paid unit is emitted."
      },
      "schema-validated": {
        "unitUsd": 0.0065,
        "eventPriceUsd": 0.0065,
        "tierPricesUsd": {
          "FREE": 0.0065,
          "BRONZE": 0.0065,
          "SILVER": 0.00585,
          "GOLD": 0.0052
        },
        "chargedBeforeOutput": true,
        "eventTitle": "Openapi Response Validator Schema Validated",
        "eventDescription": "Openapi Response Validator: charged when schema validated is completed. The price includes Apify platform usage; no separate usage pass-through is intended.",
        "triggeringCondition": "Charged before paid dataset output or the corresponding paid unit is emitted."
      },
      "contract-rule-checked": {
        "unitUsd": 0.0039,
        "eventPriceUsd": 0.0039,
        "tierPricesUsd": {
          "FREE": 0.0039,
          "BRONZE": 0.0039,
          "SILVER": 0.00351,
          "GOLD": 0.00312
        },
        "chargedBeforeOutput": true,
        "eventTitle": "Openapi Response Validator Contract Rule Checked",
        "eventDescription": "Openapi Response Validator: charged when contract rule checked is completed. The price includes Apify platform usage; no separate usage pass-through is intended.",
        "triggeringCondition": "Charged before paid dataset output or the corresponding paid unit is emitted."
      },
      "report-generated": {
        "unitUsd": 0.05,
        "eventPriceUsd": 0.05,
        "tierPricesUsd": {
          "FREE": 0.05,
          "BRONZE": 0.05,
          "SILVER": 0.045,
          "GOLD": 0.04
        },
        "chargedBeforeOutput": true,
        "eventTitle": "Openapi Response Validator Report Generated",
        "eventDescription": "Openapi Response Validator: charged when report generated is completed. The price includes Apify platform usage; no separate usage pass-through is intended.",
        "triggeringCondition": "Charged before writing the buyer-ready report artifacts to key-value storage."
      }
    }
  },
  "readmeText": "# OpenAPI Response Validator\n\n## Store Positioning\n\n**Store title:** OpenAPI Response Validator\n\n**Short description:** Validate live or supplied API responses against an OpenAPI operation’s expected response schema and return endpoint-level pass/fail evidence.\n\n**SEO title:** OpenAPI Response Validator — API, schema, and developer QA\n\n**SEO description:** Validate live or supplied API responses against an OpenAPI operation’s expected response schema and return endpoint-level pass/fail evidence. Use it to catch contract drift, schema mistakes, unsafe endpoint assumptions, and developer-tool quality issues before release.\n\n**Categories:** SEO_TOOLS, DEVELOPER_TOOLS, ECOMMERCE\n\n**Keywords:** openapi, response, validator, schema, api testing, api/developer qa\n\n## Pay-Per-Event Pricing\n\nThis actor uses pay-per-event pricing. Event prices include Apify platform usage; users are not expected to pay a separate platform-usage pass-through charge for the configured pricing model.\n\n- Tier: A1 — API/developer QA\n- Primary event: `schema-validated` at $0.00650 base\n- Default max charge: $10.00\n- Store discounts: FREE/BRONZE base, SILVER discounted, GOLD deepest approved discount\n\nEvent set:\n\n- `actor-start`: base $0.00500, GOLD $0.00400. Openapi Response Validator: charged when actor start is completed. The price includes Apify platform usage; no separate usage pass-through is intended.\n- `schema-validated`: base $0.00650, GOLD $0.00520. Openapi Response Validator: charged when schema validated is completed. The price includes Apify platform usage; no separate usage pass-through is intended.\n- `contract-rule-checked`: base $0.00390, GOLD $0.00312. Openapi Response Validator: charged when contract rule checked is completed. The price includes Apify platform usage; no separate usage pass-through is intended.\n- `report-generated`: base $0.05000, GOLD $0.04000. Openapi Response Validator: charged when report generated is completed. The price includes Apify platform usage; no separate usage pass-through is intended.\n\nThe actor accepts `actor-start` before work, accepts the primary event before each dataset row, and accepts `report-generated` before writing report files. If `maxChargeUsd` or the live PPE limit blocks a charge, the corresponding row or report is not written.\n\n## Public Task Concepts\n\n- Validate OpenAPI Response records from a capped sample\n- Find invalid OpenAPI Response values before delivery\n- Check OpenAPI Response coverage against expected rules\n- Prioritize OpenAPI Response validation failures by severity\n- Export OpenAPI Response pass-fail rows with evidence\nValidate response samples against OpenAPI operation/status schemas.\n\n## What It Does\n\nParses OpenAPI 3.x JSON, resolves local $ref schemas, and validates required fields, types, enums, nullable values, arrays, and objects.\n\n## Inputs\n\nThis actor exposes these input fields in `.actor/input_schema.json`:\n\n- `openapiSpecUrl`\n- `openapiSpecJson`\n- `operationIds`\n- `responseSamples`\n- `baseUrl`\n- `headers`\n- `allowedMethods`\n- `maxOperations`\n- `timeoutMs`\n- `validateExamplesOnly`\n- `skipUnsafeMethods`\n- `maxChargeUsd`\n\nThe exact default fetches the public Swagger Petstore OpenAPI document and validates a live bounded GET response from its inventory operation; the sources were verified at 2026-07-12T05:30:00Z.\n\n## Outputs\n\nDataset rows contain:\n\n- `operationId`\n- `method`\n- `path`\n- `statusCode`\n- `schemaFound`\n- `responseValid`\n- `errorPath`\n- `errorKeyword`\n- `expectedType`\n- `actualValue`\n- `message`\n- `recommendation`\n\nSample outputs in `examples/output.sample.json` and `output.sample.json` were generated from `examples/input.tiny.json` through actor logic.\n\n## Reports\n\nAfter the `report-generated` charge is accepted, the actor writes its Markdown, JSON, or CSV reports to the key-value store. A rejected report charge leaves those files unwritten.\n\n## Public Task Concepts\n\n- Validate OpenAPI Response Validator before release\n- Run a bounded OpenAPI Response Validator QA check\n- Generate developer QA evidence for OpenAPI Response Validator\n\n## Safe use\n\nUse small capped runs first. Network paths are bounded; review output quality and costs before increasing limits.\n",
  "inputSchemaJson": {
    "type": "object",
    "schemaVersion": 1,
    "properties": {
      "openapiSpecUrl": {
        "title": "Openapi Spec URL",
        "type": "string",
        "description": "URL to an OpenAPI JSON or YAML document to validate against.",
        "default": "https://petstore3.swagger.io/api/v3/openapi.json"
      },
      "openapiSpecJson": {
        "title": "Openapi Spec JSON",
        "type": "object",
        "description": "Inline OpenAPI document object to use instead of fetching a spec URL.",
        "additionalProperties": true
      },
      "operationIds": {
        "title": "Operation IDs",
        "type": "array",
        "description": "Operation IDs to include in the validation run. Leave empty to inspect eligible operations up to the configured cap.",
        "default": [
          "getInventory"
        ],
        "items": {
          "type": "string"
        }
      },
      "responseSamples": {
        "title": "Response Samples",
        "type": "array",
        "description": "API response samples to validate against the matching OpenAPI response schemas.",
        "default": [],
        "items": {
          "type": "object",
          "additionalProperties": true
        }
      },
      "baseUrl": {
        "title": "Base URL",
        "type": "string",
        "description": "Base API URL used when validating response samples against an OpenAPI operation.",
        "default": "https://petstore3.swagger.io/api/v3/"
      },
      "headers": {
        "title": "Headers",
        "type": "object",
        "description": "Optional request headers for authorized endpoints. Avoid secrets in shared examples and public tasks.",
        "default": {},
        "additionalProperties": true
      },
      "allowedMethods": {
        "title": "Allowed Methods",
        "type": "array",
        "description": "Allowed methods for this run. Values outside this list are skipped or flagged.",
        "default": [
          "GET"
        ],
        "items": {
          "type": "string"
        }
      },
      "maxOperations": {
        "title": "Max Operations",
        "type": "number",
        "description": "Maximum operations to process in one run; keep defaults low for safe first runs.",
        "default": 1,
        "minimum": 0,
        "maximum": 100000
      },
      "timeoutMs": {
        "title": "Timeout ms",
        "type": "number",
        "description": "Maximum time in milliseconds allowed for the OpenAPI Response Validator operation before it is treated as timed out.",
        "default": 10000,
        "minimum": 0,
        "maximum": 100000
      },
      "validateExamplesOnly": {
        "title": "Validate Examples Only",
        "type": "boolean",
        "description": "Validate Examples Only controls OpenAPI Response Validator processing for the supplied inputs; keep values conservative for first runs.",
        "default": false
      },
      "skipUnsafeMethods": {
        "title": "Skip Unsafe Methods",
        "type": "boolean",
        "description": "Skip Unsafe Methods controls OpenAPI Response Validator processing for the supplied inputs; keep values conservative for first runs.",
        "default": true
      },
      "maxChargeUsd": {
        "title": "Max Charge USD",
        "type": "number",
        "description": "Maximum estimated PPE charge allowed for the run before the actor stops gracefully.",
        "default": 1,
        "minimum": 0,
        "maximum": 100000
      }
    },
    "required": []
  },
  "datasetSchemaJson": {
    "actorSpecification": 1,
    "fields": {
      "type": "object",
      "properties": {
        "operationId": {
          "title": "Operation Id",
          "type": "string",
          "description": "OpenAPI Response Validator output field: operationId."
        },
        "method": {
          "title": "Method",
          "type": "string",
          "description": "OpenAPI Response Validator output field: method."
        },
        "path": {
          "title": "Path",
          "type": "string",
          "description": "OpenAPI Response Validator output field: path."
        },
        "statusCode": {
          "title": "Status Code",
          "type": "number",
          "description": "OpenAPI Response Validator output field: statusCode."
        },
        "schemaFound": {
          "title": "Schema Found",
          "type": "boolean",
          "description": "OpenAPI Response Validator output field: schemaFound."
        },
        "responseValid": {
          "title": "Response Valid",
          "type": "boolean",
          "description": "OpenAPI Response Validator output field: responseValid."
        },
        "errorPath": {
          "title": "Error Path",
          "type": "string",
          "description": "OpenAPI Response Validator output field: errorPath."
        },
        "errorKeyword": {
          "title": "Error Keyword",
          "type": "string",
          "description": "OpenAPI Response Validator output field: errorKeyword."
        },
        "expectedType": {
          "title": "Expected Type",
          "type": "string",
          "description": "OpenAPI Response Validator output field: expectedType."
        },
        "actualValue": {
          "title": "Actual Value",
          "type": "string",
          "description": "OpenAPI Response Validator output field: actualValue."
        },
        "message": {
          "title": "Message",
          "type": "string",
          "description": "OpenAPI Response Validator output field: message."
        },
        "recommendation": {
          "title": "Recommendation",
          "type": "string",
          "description": "OpenAPI Response Validator output field: recommendation."
        }
      },
      "additionalProperties": false
    },
    "views": {
      "overview": {
        "transformation": {
          "fields": [
            "operationId",
            "method",
            "path",
            "statusCode",
            "schemaFound",
            "responseValid",
            "errorPath",
            "errorKeyword",
            "expectedType",
            "actualValue",
            "message",
            "recommendation"
          ]
        },
        "display": {
          "component": "table"
        }
      }
    }
  },
  "strictMode": true,
  "maxChargeUsd": 1
}
```

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("junipr/x402-eligibility-checker").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("junipr/x402-eligibility-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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 junipr/x402-eligibility-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,junipr/x402-eligibility-checker"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/KOFvTjG1YqQ3285Pt/builds/d26ucWsIpgeKGB8q9/openapi.json
