Gravity Forms Copy Cat - WordPress Plugin

Guide to Setting Up and Using Gravity Forms Copy Cat

Gravity Forms Copy Cat is useful in forms where visitors should not have to enter the same data twice. This guide focuses on practical use rather than marketing copy: how field-to-field copying works, where to find the right identifiers, how to build rules with CSS classes, how to verify the result on the front end, and what to do if a value is not being copied.

The product's main advantage is that it does not create a separate settings screen with a long table of rules. The logic is defined directly in the form editor through the Custom CSS Class field. That means the quality of the setup depends on an accurate field map: which field is the source, which one receives the value, whether a checkbox trigger is needed, whether a condition applies, and whether the rule affects compound fields such as Name, Address, Email with a confirmation input, or List.

Below is a complete working workflow: preparing the form, the basic copy-1-to-2 rule, automatic copying, checkbox-based copying, multiple field pairs, specific input IDs, conditions, List fields, entry validation, and troubleshooting. At the end, you will also find related solutions, an FAQ, and a download link so you can test the plugin on a sample form after reading.

How Copy Cat Moves Values Within a Form

Copy Cat works as a small behavior layer on top of Gravity Forms. The admin adds a special class to a field, and the plugin listens for changes on the public-facing form and copies the value into another field. If the class is placed on a regular source field, copying happens automatically as the user types. If the class is placed on a Checkbox field, copying starts when the visitor checks that box.

The basic formula looks like this:

copy-{sourceFieldId}-to-{targetFieldId}

For example, the rule copy-1-to-3 means: take the value from the field with ID 1 and copy it to the field with ID 3. It is important not to confuse the two meanings of the word "class" here. In Gravity Forms, this is the Custom CSS Class field in the field appearance settings. For Copy Cat, it is not decorative CSS markup but a compact instruction the plugin reads as a copy rule.

What Happens During Automatic Copying

Automatic copying works best when the target should almost always match the source. The user enters a parent name, customer address, quantity, contract number, or some other text, and the second field receives the same value without any extra action. This mode is convenient in long forms, multi-page applications, and calculation workflows where one entered value needs to appear in another context.

The practical benefit is simple: the user sees the result immediately and understands that the form has picked it up. The practical risk is just as clear: if the target sometimes needs to be different, automatic copying can get in the way. In that case, a checkbox trigger or a conditional rule is usually a better choice so the user explicitly confirms that the values really are the same.

What Happens with Checkbox-Based Copying

Checkbox-based copying is a better fit for familiar actions such as "shipping address same as billing address." The form contains a billing section, a shipping section, and a separate Checkbox field. The Copy Cat class is added to the checkbox itself, not to the source address field. When the visitor checks the box, values from the billing fields are copied into the shipping fields.

This mode is more transparent for the user: the form does not assume the values match in advance, but offers a clear action instead. That is especially important in more complex submissions. For example, the contact person, payer, and recipient may be the same person, or they may be different. A checkbox speeds up the common case without breaking the less common one.

Bottom line: automatic mode is best for data that should always be repeated; a checkbox trigger is better when repetition is likely, but the user should confirm the choice.

Who This Plugin Is For and When Another Approach Makes More Sense

Gravity Forms Copy Cat is useful for admins who already build forms in Gravity Forms and want to reduce manual entry without creating a more complex integration. It is especially well suited to order forms, inquiries, registrations, calculators, multi-page applications, and internal workflow forms with repeated blocks of data.

Good Use Cases

• Addresses and contact details. A billing address can be copied into a shipping address, a customer name into a recipient name, or a phone number into a delivery contact field.
• Registration forms. A parent's name can be duplicated into an emergency contact field if that person is the same as the primary contact.
• Calculation forms. A Number field value can be copied into a Quantity field if it is part of a product or service calculation.
• Choice-based fields. Selected options can be copied into a List field or a text field, as long as the setup supports it and you have tested it on the specific form.
• Compound fields. You can copy specific inputs inside Name or Address fields if you specify the correct input ID.

When Copy Cat May Not Be the Best Choice

The plugin does not replace every Gravity Forms prefill mechanism. If you need to pull data from posts, users, entries, a database, or an external source, Populate Anything or built-in dynamic population is closer to what you need. If you need to pass data from one form to another, Copy Cat is also not the primary candidate: Gravity Wiz offers Easy Passthrough for that use case.

There is another important limitation: Copy Cat works as form behavior on the public-facing side of the site. The official documentation states that it does not work when editing entries in the admin panel. So you should not design a workflow as if an admin can open an entry in the backend and see interactive field-to-field copying while editing it manually. That requires a different process.

If your form collects legally significant data or payment-related values, do not make the copying invisible or unclear. The user should understand that a field was filled automatically and should be able to correct it if the value does not match reality. Copy Cat speeds up data entry, but it does not remove the need for thoughtful form design.

What to Check Before Installation

You do not need complex infrastructure before installation, but you do need to understand which forms you are going to modify. Copy Cat is especially sensitive to accurate field IDs and to where exactly the class is placed. A single wrong digit can look like "the plugin does not work," when in fact the rule is simply pointing to the wrong place.

Create a Field Map Before Setup

Open the form in the Gravity Forms editor and list the fields that will be involved in copying. For each rule, note the following:

• The source field name in the editor.
• The source field ID.
• The target field name.
• The target field ID.
• Whether you need automatic mode or a checkbox trigger.
• Whether there is a condition that should allow or block the copying.
• Whether a compound input is involved, such as first name, last name, state, or confirmation email.

For a simple text field, the field ID is enough. For Name, Address, Email with confirmation, and similar compound fields, you often need an input ID such as 1.3, 2.6, or 4.4. In those cases, the rule becomes more precise, but the cost of a mistake is higher.

Check the Theme, Cache, and JavaScript

Copy Cat depends on JavaScript on the front end of the form. Before setting it up, it is useful to open the form page in a browser, make sure the form itself renders without errors, and confirm that there are no obvious JavaScript errors in the console. You do not need to disable every plugin in advance, but if the form is already behaving inconsistently, fix that base issue first and only then add Copy Cat.

Cache usually should not interfere with the rule itself, but it can show an older version of the page or stale assets. After changing classes, save the form, clear the page cache if there is one, and test the result in a private window or with a refresh parameter. This is especially helpful on sites where the form is embedded in a page builder or uses AJAX updates.

Administrator Permissions

The setup is done in the Gravity Forms editor. The user configuring the plugin must have access to the form, field settings, and the ability to save changes. If you plan to use official JavaScript snippets through Code Chest, also confirm that the required role can see that tool in the settings for the specific form.

Installation and Initial Verification After Activation

Installation is the same as for a regular WordPress plugin: upload the ZIP archive, activate it in the Plugins section, then open the target form in Gravity Forms. This guide does not cover purchasing, license keys, or getting the paid version. The point of this stage is simply to confirm that the product you already have is active and available while editing the form.

After activation, do not look for a separate global "Copy Cat rules" screen. The real work happens in the field settings. Open the form, choose the source field or checkbox trigger, go to the appearance settings, and find Custom CSS Class. That is where the Copy Cat formula is added.

A Small Test on a Separate Form

Do not start with a production form that has dozens of fields, conditional logic, and notifications. Create a temporary test form with two Single Line Text fields:

1. Add a field called "Source value."
2. Add a field called "Target value."
3. Note the IDs of the first and second fields.
4. Add a class like copy-1-to-2 to the source field, replacing the numbers with the real IDs.
5. Save the form and open its preview or the page where it is embedded.
6. Enter text into the source field and check whether it appears in the target field.

This test only takes a few minutes, but it immediately separates installation issues from issues in a specific larger form. If the simple form works and the complex one does not, the next things to inspect are IDs, conditional logic, hidden fields, class placement, or JavaScript on the page.

How to Add the Class If the Field Already Has Other Classes

Gravity Forms allows multiple classes in Custom CSS Class. They must be separated by spaces. If the field already has a layout class or your own custom class, do not remove it without a reason. Just add the Copy Cat rule at the end:

existing-class copy-1-to-2

Do not use a comma, semicolon, or line break instead of a space. For Copy Cat, that becomes different text, and the rule may not be recognized. After saving the form, open the public preview, because some CSS classes are not always obvious inside the form editor itself.

CSS Class Grammar: Source, Target, and the Right Placement

The most important Copy Cat setting is not a toggle but the syntax. Because the rule is short, it is easy to type by eye and get wrong. It is better to think of it as a small data map: where the value comes from, where it goes, and when the action runs.

One Source and One Target

The basic case:

copy-1-to-2

This means "copy field ID 1 into field ID 2." In automatic mode, the class is placed on the source field. When the visitor changes the source, Copy Cat copies the value to the target. For text fields, this is the simplest and most reliable option.

One Source and Multiple Targets

If one value needs to be copied to several places, add multiple Copy Cat classes to a single field:

copy-1-to-2 copy-1-to-3

This is useful when the same name, address, or numeric value is used in different parts of the form. The key is not to turn the form into a hidden dependency network. If the target fields will later be edited manually, explain their purpose to the user through the field label or description.

Multiple Field Pairs

For batch copying, you can place multiple pairs together:

copy-1-to-2 copy-3-to-4 copy-5-to-6

A common scenario is copying a billing group into a shipping group: name, email, phone, and address. If the rule is triggered by a checkbox, all of these classes are placed on the Checkbox field. If they run automatically, the classes are usually distributed across the corresponding source fields. The right choice depends on the UX: a single shared checkbox works well for "same as billing," while automatic pairs work better for unconditional repetition.

How to Choose the Field Where the Class Belongs

The rule should be placed where the event happens that Copy Cat needs to respond to:

• For automatic copying, place it on the source field.
• For checkbox-based copying, place it on the Checkbox field the user checks.
• For a conditional rule, it is often placed on the condition field, because that field's change should trigger the evaluation.

This is a common source of mistakes. An admin may think, "I am copying from the source, so the class must always go on the source." But if the rule depends on a checkbox or radio choice, it is the trigger field that needs to be watched. So during debugging, ask not "which field is the main one," but "which field changes at the moment the copy should happen."

Automatic Copying or Checkbox Trigger: How to Choose the Behavior

Both modes can use the same copy-{source}-to-{target} formula, but they create very different user experiences. A good form does not just copy data correctly from a technical standpoint - it does so in a way that feels predictable to the person using it.

When to Use Automatic Copying

Automatic copying is appropriate when the target field is conceptually a repeat of the source field. For example, in a service booking form, the customer enters a "Client address," and below that there is a hidden or helper field used for distance calculations. If that field should always match the address, adding a checkbox only makes the form more complicated.

Another example is a multi-page form where the name or email is needed again on the next page for context. The user has already entered the data, and the form can show it in a new section without asking them to type it again. In that case, automatic copying saves time and reduces the chance of mismatch.

When a Checkbox Is Better

A checkbox is the better option when the match is likely but not guaranteed. Billing and shipping addresses are the classic example. One customer may have the same address for both, while another may not. If the form silently copies the address every time, some users will end up fighting the autofill behavior. If the form offers a checkbox, the user gets to choose the faster path.

A checkbox is also useful when copying an entire group of fields. One clear action is easier to understand than several invisible automatic transfers. This matters especially in order forms, event registrations, delivery forms, consultation requests, or forms involving multiple participants.

When to Use a Condition

A condition is useful when the copy should depend on a selection in Radio Buttons, a Drop Down, or a Checkbox. The formula gets an -if-{condition} suffix:

copy-3-to-4-if-1.0

In that form, the rule means: copy field ID 3 into field ID 4 if the first option is selected in condition field ID 1. For Radio and Drop Down fields, option indexing starts at 0. For Checkbox fields, the Copy Cat documentation uses a different order: the first checkbox choice is 1, the second is 2. That difference needs especially careful attention.

Compound Fields, Input IDs, and List Fields

Simple text fields rarely raise questions. The complexity begins when a field contains multiple inputs. Name stores different name parts separately, Address stores street, city, state, and other parts, Email may include a confirmation input, and List can work with rows and columns. Copy Cat supports these scenarios, but it requires precise input IDs.

Copying Part of a Name Field

If you need to copy only the last name from one Name field to another, use the input ID. The official examples use a format like this:

copy-1.3-to-2.3

This notation means a specific input inside the field is being copied. For a different name format, the input numbers may be different, so do not drop the example into a production form without checking. Open the field, confirm the ID, and run a test entry.

Email Confirmation and the Second Input

If the source field is an Email field with confirmation enabled, the Copy Cat documentation specifically notes that the confirmation input should reference the second input ID. For example:

copy-1.2-to-4

This matters in forms where the user enters an email address twice and that value is then used elsewhere. If you copy the wrong input, the target may stay empty or receive the value at a time you did not expect.

List Fields and Multiple Values

Copy Cat can work with List fields in several ways: copying one List into another, moving a multi-value field into a List, or copying a value into a specific List column. For example, a Multi Select field can be sent to the third column of a List field with a formula like this:

copy-5-to-6.3

This scenario is useful in forms involving selected services, participants, products, or parameters. But a List field should be verified not only visually, but also through the submitted entry. The front end may look correct, while the entry itself is where you confirm that rows and columns were actually saved in the expected format.

Practical rule: the more complex the field type, the less you should trust a template example and the more you should verify the exact IDs, the saved entry, and the behavior when the source changes again.

Detailed Setup After Installation: From One Rule to a Maintainable Form

After the initial test, the admin's main job is not just to add the required classes, but to build the form in a way that will still make sense a month later or after a colleague edits it. Copy Cat does not store rules in a separate table, so your form documentation becomes part of the configuration itself. That is especially important for order forms, long applications, and internal workflows where one field may affect notifications, calculations, and the visibility of other sections.

Start with Clear Field Names and Descriptions

Before adding Copy Cat classes, make sure the labels and admin labels are easy to understand. If the form contains two fields both called "Address," it will be difficult a week later to tell which one is billing and which one is shipping. It is better to use visible labels that make sense to the user and, when needed, admin labels that help the administrator in entries and settings.

For the user, the label should make clear what they are entering. For the administrator, the field map should explain why that field is part of the copy process. For example, "Billing Address" and "Shipping Address" are clearer than two identical "Address" labels. In large forms, it is helpful to group fields with section breaks: billing block, shipping block, emergency contact, attendee details. Copy Cat does not directly depend on that structure, but maintenance becomes much easier.

Add Rules in Small Batches

Do not paste ten pairs into a checkbox trigger all at once. Start with one pair, save the form, and test the result. Then add the second and third. This order helps you quickly identify where an ID mistake was made. If you add everything at once, the symptom will be just one thing - "it does not work" - while the causes may be several: a wrong input ID, the wrong trigger field, a hidden target, a typo, or a JavaScript conflict.

For grouped copying, it helps to keep a working table in your project notes:

You do not need to publish this table on the site. It is a working document that reduces the risk of accidentally breaking a rule when the form is updated.

Settings to Enable Only When Necessary

In a standard Copy Cat setup, CSS classes are often enough. Hooks and snippets should be considered only when the default logic does not cover the task. For example, if you need to copy the label instead of the value, the official snippet library provides a ready-made solution through gpcc_copied_value. If you need to change the set of fields passed to the front-end script, there is gpcc_copy_cat_fields. If you need to overwrite target values when the form initializes, the documentation describes gpcc_overwrite_existing_values_on_init.

Do not enable these extensions "just in case." They change form behavior more deeply than a standard class does. Before applying them, define the exact problem: "the target is already filled by dynamic population, but in this form the source should take priority"; "the choice value is technical, but the operator needs the label"; "the condition should choose a different source based on the trigger." If you do not have that specific problem, leave the default behavior alone.

How to Roll Back the Setup Safely

Rolling back Copy Cat is simple as long as you have not mixed the standard classes with a large amount of custom JavaScript. Remove the Copy Cat class from Custom CSS Class, save the form, clear the page cache, and run the test again. If Code Chest or another official snippet workflow was used, disable the snippet only for the relevant form and confirm that the standard fields still save correctly.

Before changing a production form, it is helpful to make a copy of the form or save the class list in your notes. That way, rollback does not turn into an attempt to reconstruct old IDs from memory. This matters especially for multi-page forms and submissions where changes may affect notifications, integrations, and internal processing.

The best Copy Cat setup is not the longest set of classes, but the clearest source -> target map, the smallest amount of custom code, and verification of every pair on the public form and in the saved entry.

Conditional Copying and Scenarios Where Mistakes Are Easy to Make

Conditional copying looks simple: add -if- and specify the condition field. In practice, this is the most common source of subtle errors, because the rule needs to know not only the source and target, but also which field to listen to. If the condition changes after the source value was entered, Copy Cat needs to receive that signal from the condition field itself.

The "If Field Is Filled" Rule

The gentlest conditional variant is to copy only when another field has a value. The formula may look like this:

copy-1-to-3-if-2

The meaning is: copy field 1 into field 3 if field 2 is not empty. This approach works well in forms where the user first sets the context and then the form copies a name, address, or other field into a related block. For example, copy attendee details into "Guest details" only if the user indicates that there will be a guest.

Test both paths: when field 2 is empty and when field 2 is filled. If you test only the positive path, you may miss the fact that the target is being filled even when the condition is not met.

Rule Based on a Selected Option

For Radio Buttons and Drop Down fields, the condition can point to a specific choice. The documentation example uses this format:

copy-3-to-4-if-1.0

Here, 1.0 means the first option in the condition field. This is useful for scenarios like "if Yes is selected, copy the data," "if the customer type is Company, copy the company details," or "if the delivery method is Pickup, fill in the pickup contact." But do not forget that the selection may change after the copy has happened. If the user first chooses Yes and the target is filled, then switches to No, verify that the form behaves the way you expect. Sometimes the target should be cleared; sometimes it is enough to leave the value for manual correction.

Condition and Gravity Forms Conditional Logic

Gravity Forms conditional logic controls field visibility, while Copy Cat moves values. The two can work together, but they should be tested as a system. Imagine an event registration form: if the user selects "I need invoice," an invoice data block appears, and Copy Cat copies the billing company into the invoice company field. If that block is hidden, the key question is whether the value should still be saved. The answer depends on the business process, not on the plugin.

Check cases like these:

• The target field is visible before the copy happens.
• The target field becomes visible after the condition is selected.
• The target field becomes hidden again after the condition changes.
• The user manually changed the target after it was filled automatically.
• The form is submitted after the condition was toggled several times.

If one of these paths leads to ambiguous results, change the UX. Sometimes it is better to show the checkbox only after the target section is available. Sometimes it is better to leave the target visible but mark it as optional. Sometimes conditional copying should be replaced with a manual checkbox because the user needs to explicitly confirm the action.

Copying into Calculation and Product Fields

Copy Cat can be part of workflows involving Product and Quantity fields, as long as the field is supported in the required configuration. But those forms need separate testing, because the value may affect the final total, notifications, and the saved entry. If a Number field is copied into a Quantity field, verify not only the visible value, but also the total recalculation, the submitted entry, and the notification.

Do not create hidden transfers into price or quantity fields if the user cannot tell where the result came from. For calculation workflows, it is helpful to add a description near the source field or target section: the user should see which entered value affects the calculation. That reduces disputed submissions and support requests.

When Not to Overcomplicate It

If a rule already includes several pairs, input IDs, a condition, and a custom snippet, stop and ask whether the form should simply be redesigned. Sometimes a separate step, a clear checkbox, or a clearer label is more reliable than a smart rule no one will be able to verify quickly. Copy Cat is strongest when it handles simple, repeatable routes. Once the route starts turning into a mini-application, you need a more explicit form design and possibly a different tool.

Practical Scenario: Copying a Billing Address to a Shipping Address

Let us walk through a concrete example, because it shows both the strengths and the limitations of the plugin very clearly. The goal is simple: in an order form, the user enters a billing address, checks a box labeled "Shipping address is the same," and the shipping fields are filled with the same values. If the addresses are different, the user leaves the box unchecked and enters the shipping address manually.

Goal

Reduce repeated address entry without taking control away from the user. After setup, the form should behave like this: the billing group remains the main source of data, the shipping group is filled via the checkbox, and the user can still edit the shipping fields if the delivery address is different.

Preparation

The form should include:

• A Billing Address field or a group of separate billing fields.
• A Shipping Address field or a group of separate shipping fields.
• A Checkbox field with a clear label such as "Use billing address for shipping."
• Known field IDs and, if necessary, input IDs for parts of the Address field.

If you are using two full Address fields, first verify whether field-to-field copying works on a test form. If the form uses separate fields for street, city, state, and ZIP code, the setup will consist of several pairs.

Setup Steps

1. Open the form in the Gravity Forms Form Editor.
2. Find the billing fields and shipping fields, and write down their IDs.
3. Open the Checkbox field that should trigger the transfer.
4. Go to the field appearance settings and find Custom CSS Class.
5. Add one or more Copy Cat pairs. For separate fields, it may look like this: copy-3-to-8 copy-4-to-9 copy-5-to-10.
6. Save the form.
7. Open the preview or the page with the form, enter billing data, and check the box.

If you are using an Address field with input IDs, the classes will be more precise and longer. For example, a separate state input may be copied into a separate field or into an input inside another Address field. Do not guess the ID here: open the field details, verify the structure, and test one pair before adding the full group.

Verification

After the box is checked, the shipping fields should receive the values from the billing fields. Then run the reverse test: uncheck the box, change the billing address, and check the box again. If the target values do not behave as expected, review whether Copy Cat should clear or overwrite already changed target fields in your scenario. By default, behavior with prefilled target values needs careful handling: the official documentation describes a separate filter for overwrite on init, which means these cases should not be treated as universal.

Nuance

If the shipping fields have their own conditional logic and appear only after a certain option is selected, verify the order of actions. Sometimes the user checks the box before the target fields become visible. In that case, it is better to adjust the UX: first show the shipping section or the checkbox itself, then trigger copying at the moment when the target fields are already available.

Verifying the Result on the Site and in the Entry

Testing Copy Cat does not end when the target field looks filled visually. You need to confirm that the value is saved in the entry, used in notifications, applied correctly in calculations, and does not break conditional logic.

The Public Form

Open the form as a regular visitor would. Do not test only in the admin preview if the real form is embedded on a live page through a block, shortcode, or page builder. The test should follow the actual user path: page, fields, checkbox, multi-page transition, confirmation, and submission.

Minimum test:

1. Enter a value in the source field.
2. Check the target field before submission.
3. Change the source field and confirm that the target updates at the expected moment.
4. If a checkbox is used, test the behavior before it is checked and after it is checked.
5. If a condition is used, test both paths: condition met and condition not met.

The Entry in the Admin Panel

Submit a test entry and open it under entries. Compare the source and target values. If the target looked filled on screen but is empty in the entry, check whether the field is hidden by conditional logic at the moment of submission, whether it is marked as administrative-only in the wrong place, or whether another script is overwriting it. In Gravity Forms, hidden conditional fields can behave differently from visible fields, so those cases need separate testing.

Notifications and Confirmations

If the target field is used in an email notification, confirmation text, or calculation, run a test that includes a real submission and notification delivery. Do not stop at preview mode. For an order form or inquiry form, it is important to verify not only that the field was filled, but also that the operator receives a clear submission without duplicates, empty columns, or unexpected values.

Good result verification covers three levels: the visible field on the page, the saved entry, and downstream use of the value in notifications, calculations, or submission processing.

Common Issues and Troubleshooting

Most Copy Cat issues come down not to installation, but to rule accuracy and the moment when the rule is supposed to run. Below is a practical symptom-based troubleshooting guide.

The Target Field Does Not Fill at All

Symptom: the user enters a value in the source, but the target stays empty.

First, check the class syntax. It should follow the format copy-{sourceFieldId}-to-{targetFieldId}. Common mistakes include swapping source and target, using a label instead of an ID, putting a comma between multiple classes, adding the class to the wrong field, or including extra characters in the class.

Then check the placement. For automatic mode, the class belongs on the source field. For a checkbox trigger, it belongs on the Checkbox field. For a condition, it belongs on the field whose change should trigger the rule. If the class is placed on a static field that never changes, Copy Cat may simply never receive the event it needs.

Copying Works in a Simple Form but Not in the Real One

Symptom: a two-field test form works, but the larger form with conditional logic does not.

Look for a conflict in the form environment. Check whether the source or target field is hidden by conditional logic at the time of copying. Check the page for JavaScript errors in the console. You do not need to disable everything at random, but if an error appears before any form interaction, it may interrupt Copy Cat on the front end.

If the form is multi-page, verify the actual page where the source and target live. If Copy Cat is supposed to copy a value to another page in the form, test the transitions and confirm the value remains after navigation. Not all problems show up on the first page.

The Wrong Value Is Copied for Radio, Drop Down, or Checkbox Fields

Symptom: the target receives the technical value, but the operator expected a readable label.

The official documentation and snippet library indicate that for choice-based fields, the value may be copied by default. If you need the label, use the official Copy Label (instead of Value) snippet and apply it through a recommended method such as Code Chest or a Custom JavaScript workflow. Do not drop random JS into an HTML field without understanding where it runs and which forms it affects.

If the value and label are intentionally different, first decide what should actually be stored in the entry. Integrations often need the value. For an operator reading an email, the label may be more useful. Sometimes the right fix is to change the notification, not the copied value.

The Condition Runs Backward or Does Not Run at All

Symptom: the copy should happen only when a certain option is selected, but instead it always runs or never runs.

Check the -if-{condition} suffix. In Copy Cat examples, the choice index for Radio and Drop Down starts at 0, while Checkbox choices use a different numbering scheme. Then check which field the class is placed on. In a conditional scenario, Copy Cat needs to listen for changes on the condition field, otherwise the rule may not be recalculated at the right time.

The Target Field Receives an Old or Pre-Populated Value

Symptom: the target already contains a value when the form loads, and Copy Cat does not replace it the way you expected.

The official documentation includes a separate gpcc_overwrite_existing_values_on_init filter. That means behavior with pre-populated target values should be designed deliberately. If the target should keep its pre-populated value, do not enable overwriting. If the source should take priority, test the official filter on a sample form and apply it only where you fully understand the consequences.

Copying Breaks After Adding a Snippet

Symptom: basic Copy Cat works, but after adding custom JS, some fields stop updating.

Roll back the snippet and return to the clean formula. If the problem disappears, the issue is in the customization. Use official Code Chest or the recommended snippet workflow, keep the JS scoped to the specific form, and do not manually duplicate render events if the tool already runs the code on the correct event. If the form matters, standard Copy Cat behavior is usually better than maintaining a complex snippet without tests.

Video: Copying a Billing Address to a Shipping Address

Gravity Wiz's official materials include a precise Copy Cat video for the "auto copy billing address to shipping address" scenario. It works well as a visual validation of the intent cluster: copying an address in Gravity Forms, using a checkbox for identical billing and shipping addresses, and verifying the result on the form. Watch it after reading the practical example section - that makes it easier to match field IDs, the trigger checkbox, and the expected behavior.

When Gravity Forms Copy Cat Is the Right Choice

Gravity Forms Copy Cat is worth using when the task can be stated clearly like this: "the user enters a value in one field, and the form should copy it into another field in the same form." If you can draw a source -> target map and explain when the copying should run, the plugin usually gives you a simple, maintainable result.

Before rolling it out on a live site, run a short test: one form, two fields, one class, one submitted entry. Then add the checkbox, multiple pairs, input IDs, and conditions. That order may feel slow, but it is much faster than debugging ten classes in a long form without knowing which pair broke.

If, after setup, you realize you do not need in-form copying but dynamic loading from a data source, form-to-form transfer, or complex external database logic, choose another tool. But for repeated contact details, addresses, names, quantities, lists, and conditional copying inside Gravity Forms, this product remains a very precise solution.

Once the field map is ready and the test form works, you can get the WordPress version, install it on a test site, and validate your real workflow: automatic copying, checkbox trigger, condition, saved entry, and operator notification.