Schema Tools: Diff, Registry & Input Guard

ApifyForge includes three schema tools that help you understand actor data before you use it: the Schema Diff for comparing output between actors, the Schema Registry for browsing all actor fields, and the Input Guard for validating actor inputs before running. These tools prevent the two most common data pipeline failures: unexpected output format changes and invalid input parameters.

Schema Diff

The Schema Diff at apifyforge.com/tools/schema-diff compares the output schemas of two Apify actors side by side.

The problem it solves

You are using Actor A to scrape Google Maps and feeding the output into a spreadsheet, database, or LLM pipeline. Actor A gets deprecated, starts failing, or raises prices. You want to switch to Actor B, which does the same job. But will Actor B's output break your pipeline?

The answer depends on field compatibility. If Actor A outputs businessName and Actor B outputs name, your spreadsheet column mapping breaks. If Actor A outputs rating as a number (4.5) and Actor B outputs it as a string ("4.5/5"), your database insert fails on a type constraint. These differences are invisible until something breaks in production.

How to use it

Select two actors from the dropdowns. The diff shows four categories instantly:

• Shared fields — fields that exist in both actors with the same name and type. These are drop-in compatible and need no changes in your pipeline.
• Type mismatches — fields with the same name but different types. For example, price is a string in Actor A but a number in Actor B. These require a type conversion step in your pipeline.
• Unique to Actor A — fields in Actor A that do not exist in Actor B. If your pipeline uses any of these fields, you will lose that data when you switch.
• Unique to Actor B — new fields Actor B provides that Actor A did not. You might want to start using these.

Making the switch

Once you see the diff, the migration path is clear. For shared fields with matching types, no changes needed. For type mismatches, add a transformation step (cast string to number, parse date formats, etc.). For fields unique to Actor A that your pipeline depends on, you either find an alternative source for that data or accept the loss. The diff turns a risky actor swap into a checklist.

Schema Registry

The Schema Registry at apifyforge.com/tools/schema-registry is a searchable catalog of actor output schemas.

Two modes

Browse mode shows all actors with expandable schema details. Click any actor to see its complete field list with types (string, number, boolean, array, object) and descriptions. This answers the question "What data does this actor return?" without having to run it first.

Find Field mode lets you search for a specific field name across all actor schemas. Type email and the registry returns every actor whose output includes an email field. Type rating and you see all actors that output ratings. This answers the question "Which actors give me the data I need?"

Use cases

Before buying an actor — check the Schema Registry to see exactly what fields it outputs. The Apify Store page shows a description and maybe a sample, but the registry gives you the definitive field list with types.

Finding alternative data sources — if you need email addresses, search for email in Find Field mode. You might discover actors you did not know about that output emails as a side product of their main purpose (like a website contact scraper or a LinkedIn profile extractor).

Pipeline planning — when designing a multi-actor pipeline, the registry lets you check whether Actor B's input can be satisfied by Actor A's output without having to run either one.

Input Guard

The Input Guard at apifyforge.com/tools/input-tester lets you build and validate actor input JSON using the actor's declared input schema.

The problem

Apify actors accept JSON input that conforms to a schema. When you run an actor with invalid input — a missing required field, a string where it expects a number, or an enum value that is not in the allowed list — the run either fails immediately (wasting compute credits) or produces unexpected results. The Apify Console catches some of these errors with its form UI, but if you are calling actors via API, there is no form to guide you.

How to use it

Select an actor from the catalog. The tester loads its input schema and renders an interactive form:

• Text inputs for string fields with validation (min/max length, regex patterns)
• Number spinners for integer and number fields with min/max constraints
• Checkboxes for boolean fields
• Dropdowns for enum fields showing all allowed values
• Tag inputs for array fields (like lists of URLs or keywords)
• Required field indicators showing which fields must be provided

As you fill in the form, validation runs in real time. Required fields that are empty turn red. Numbers outside allowed ranges show a warning. Enum values not in the allowed set are flagged.

Two views

The form view is for building input interactively. The JSON view shows the raw JSON being generated, which you can copy directly for use in API calls, CLI commands, or automation workflows. Both views stay in sync — edit the form and the JSON updates, edit the JSON and the form updates.

Saving credits

A failed actor run due to bad input typically costs $0.001-0.01 in compute — it starts, validates input, fails, and stops. That does not sound like much, but if you are iterating on input parameters and triggering 10-20 failed runs to get the format right, the cost and time add up. The Input Guard eliminates this by validating everything locally before you spend anything.

All three tools run entirely in your browser with preloaded schema data. No API calls, no actor runs, no costs.