ACF Frontend Forms in WordPress: Complete Guide

You’ve defined your ACF field groups to structure content perfectly in wp-admin. Now the client wants the same data collected from the frontend. Do you rebuild everything in a separate form plugin? Duplicate all your field definitions? Or find a way to reuse the ACF fields you’ve already built?

This guide covers every approach to building ACF-powered frontend forms so you can choose the right one for your project.

What Are ACF Frontend Forms?

ACF frontend forms render Advanced Custom Fields field groups on the public-facing side of your WordPress site. Instead of requiring users to log into wp-admin, you can present forms that let visitors create posts, edit their profiles, submit applications, or provide structured data — all using the same ACF fields you’ve already defined.

Unlike standalone form builders (Gravity Forms, WPForms), ACF frontend forms use the same field definitions you’ve already created — so admin and frontend stay in sync with no duplicate configuration.

Common use cases include:

• Post submission forms — let users submit listings, articles, or directory entries
• User profile editors — front end forms for updating profile information and custom user fields
• Contact and enquiry forms — structured data collection using ACF field types like repeaters, date pickers, and file uploads
• Membership applications — multi-step onboarding flows with conditional fields
• Property or product listings — structured submissions with images, maps, and categorisation

Because ACF frontend forms use the same field definitions as your admin interface, any data submitted through the frontend is immediately available in wp-admin — and vice versa. There’s no sync layer, no data mapping, and no separate form configuration to maintain.

Approach 1: ACF’s Built-In acf_form() Function

ACF provides a function called acf_form() that renders a field group as an HTML form on the frontend. It’s available in both ACF Free and ACF Pro and handles field rendering and data saving out of the box.

Basic Usage

To render a frontend form that creates a new post:

<?php
// Must be called before get_header()
acf_form_head();
get_header();
?>

<?php
acf_form([
    'post_id'      => 'new_post',
    'new_post'     => [
        'post_type'   => 'listing',
        'post_status' => 'draft',
    ],
    'field_groups'  => ['group_abc123'], // Your field group key
    'submit_value'  => 'Submit Listing',
    'updated_message' => 'Listing submitted successfully.',
]);
?>

<?php get_footer(); ?>

This gives you a working form that creates a new listing post with the fields from your specified field group. When submitted, ACF saves the field data to the post automatically.

You can also use acf_form() to edit existing posts or users by passing a post ID or user ID:

// Edit an existing post
acf_form(['post_id' => 42]);

// Edit a user profile
acf_form(['post_id' => 'user_5']);

What acf_form() Handles

• Rendering all field types from the specified field group(s)
• Saving field data to posts, users, or options pages on submission
• Basic nonce verification and security
• Honeypot spam protection (enabled by default)
• An update/success message after submission

What acf_form() Doesn’t Handle

• Email notifications — you need custom code to send confirmation or admin notification emails
• reCAPTCHA — the built-in honeypot catches basic bots, but there’s no reCAPTCHA or advanced spam protection
• AJAX submission — forms submit with a full page reload
• Multi-step forms — no built-in support for breaking forms into pages
• Access control — no restriction on who can see or submit the form
• Entry management — no way to view, search, or export submissions from wp-admin
• Submission limits — no built-in way to cap total submissions or restrict by time window

For a simple, single-purpose form where you’re comfortable writing PHP to fill these gaps, acf_form() works well. For anything more complex, the custom code required grows quickly.

Approach 2: Custom PHP Form Handler

If you want full control over form rendering and submission handling, you can build your own form handler in PHP.

Basic Pattern

<?php
// Process form submission
if ($_SERVER['REQUEST_METHOD'] === 'POST' && wp_verify_nonce($_POST['_wpnonce'], 'my_acf_form')) {
    $post_id = wp_insert_post([
        'post_type'   => 'listing',
        'post_status' => 'draft',
        'post_title'  => sanitize_text_field($_POST['listing_title']),
    ]);

    if ($post_id) {
        // Save ACF fields
        update_field('price', floatval($_POST['price']), $post_id);
        update_field('location', sanitize_text_field($_POST['location']), $post_id);
        update_field('description', wp_kses_post($_POST['description']), $post_id);

        wp_redirect(add_query_arg('submitted', '1', get_permalink()));
        exit;
    }
}
?>

<form method="post">
    <?php wp_nonce_field('my_acf_form'); ?>
    <label>Title</label>
    <input type="text" name="listing_title" required>

    <label>Price</label>
    <input type="number" name="price" step="0.01">

    <label>Location</label>
    <input type="text" name="location">

    <label>Description</label>
    <textarea name="description"></textarea>

    <button type="submit">Submit Listing</button>
</form>

When Custom PHP Makes Sense

This approach gives you full control over every aspect of the form — rendering, validation, submission handling, and response. It works with both ACF Free and Pro since you’re using update_field() to save data.

However, you lose ACF’s field rendering — you’re building plain HTML form fields instead of getting ACF’s rich field types (repeaters, galleries, date pickers, conditional logic). You’re also responsible for sanitising every input, handling file uploads securely, building notification logic, and managing error states.

For a single, simple form this is manageable. But the complexity compounds quickly when you need multiple forms, different field configurations, file uploads, or conditional logic. Most developers who start with custom PHP eventually migrate to a dedicated form solution once requirements grow beyond one or two forms.

Approach 3: Advanced Forms

Advanced Forms is a form plugin built specifically for ACF. It provides a complete form management layer on top of ACF’s field system — handling everything that acf_form() and custom PHP leave to you.

Note: Advanced Forms requires ACF Pro v5.7 or later. Both the free version and Pro version have this requirement.

How It Works

1. Create a form in the Advanced Forms admin screen
2. Assign ACF field groups to the form using ACF’s standard location rules
3. Configure settings — email notifications, entries, redirects, spam protection
4. Display the form using a shortcode, Gutenberg block, or PHP function

// Shortcode


// PHP function
advanced_form('form_abc123');

// With AJAX enabled

The form renders using ACF’s native field rendering, so every field type works exactly as it does in wp-admin — including repeaters, galleries, WYSIWYG editors, and conditional logic.

Want to skip the infrastructure code and get straight to building forms? Advanced Forms handles notifications, entries, AJAX, multi-step, and spam protection out of the box.

Feature Comparison

The key trade-off: acf_form() gives you field rendering and data saving but nothing else — you build the rest yourself. Advanced Forms gives you the complete form infrastructure (notifications, entries, AJAX, multi-step, spam protection) so you can focus on the form’s purpose rather than its plumbing.

The free version of Advanced Forms covers most use cases. The Pro version adds post and user editing, calculated fields, reCAPTCHA, and third-party integrations (Slack, Zapier, Mailchimp).

Choosing the Right Approach

Use acf_form() when:

• You need a simple post or user editing form
• You’re comfortable writing PHP for notifications, validation, and additional spam protection
• You don’t need entry management, AJAX, or multi-step forms
• You want the lightest-weight option with no additional plugins

Use custom PHP when:

• You want full control over form rendering and don’t need ACF’s field UI on the frontend
• You have very specific submission handling requirements that don’t fit a plugin’s model
• The form requirements are unlikely to grow beyond what you’ve built

Use Advanced Forms when:

• You need email notifications, entries, or multiple forms
• You want non-developers to be able to manage forms
• You need multi-step forms, AJAX submission, or spam protection
• You want to avoid building and maintaining custom form infrastructure

As a rule of thumb: if you find yourself writing more code to handle form infrastructure (notifications, validation, spam protection, entries) than to solve your actual business problem, a dedicated form plugin will save you time.

Common Use Cases

Post Submission Form

Let visitors submit blog posts, directory listings, or classified ads. Advanced Forms Pro maps form fields directly to post fields — title, content, featured image, taxonomies, and any ACF custom fields.

The submitted data creates a WordPress post (with whatever post status you configure), so it immediately appears in wp-admin for review.

Learn more about creating and editing posts with Advanced Forms →

User Profile Editor

Build a frontend profile page where users can update their information without accessing wp-admin. Map form fields to WordPress user fields (display name, email, password) and ACF user fields (biography, avatar, social links, preferences).

With acf_form(), you can achieve basic user editing by passing 'post_id' => 'user_5'. Advanced Forms Pro adds a dedicated user editing mode with additional controls for which user fields are editable.

Learn more about creating and editing users with Advanced Forms →

Multi-Step Forms

Break long forms into logical steps using the Page field type provided by Advanced Forms. Each Page field creates a step boundary with automatic Previous/Next navigation. This works particularly well for applications, onboarding flows, and surveys where presenting all fields at once would overwhelm users.

Read our guide to creating multi-step forms with ACF →

Storing Form Data in Custom Database Tables

If your forms collect structured data that you’ll need to query, filter, or export at scale, consider storing submissions in custom database tables instead of wp_postmeta. The ACF Custom Database Tables plugin integrates directly with Advanced Forms to store entry data in organised, structured tables.

Read our guide to storing ACF data in custom database tables →

Frequently Asked Questions

Does acf_form() require ACF Pro?

No. acf_form() is available in both ACF Free and ACF Pro. It has been part of ACF’s core since version 5. You can use it to render frontend forms, create posts, and edit existing posts or users without purchasing ACF Pro.

Does Advanced Forms require ACF Pro?

Yes. Both the free and Pro versions of Advanced Forms require ACF Pro v5.7 or later. This is because Advanced Forms extends ACF Pro’s field system with custom field types and form management features.

What’s the difference between Advanced Forms Free and Pro?

The free version includes email notifications, AJAX submissions, form entries, honeypot spam protection, submission limits, multi-step forms, and Gutenberg block support. The Pro version adds post creation/editing, user registration/editing, calculated fields, reCAPTCHA, and integrations with Slack, Zapier, and Mailchimp.

Can I use ACF frontend forms with WooCommerce?

Yes. You can build frontend forms that read and write WooCommerce product fields, order metadata, or any other third-party post meta. Both acf_form() and Advanced Forms handle this through ACF’s standard field mapping.

Learn more about managing third-party metadata with ACF forms →

Can I store form submissions in a custom database table?

Yes. When using Advanced Forms with ACF Custom Database Tables, form entries are automatically stored in structured database tables instead of wp_postmeta. This is ideal for high-volume forms or when you need fast SQL queries against submission data.

Is AJAX form submission supported?

In Advanced Forms (both free and Pro), add ajax="1" to the shortcode or 'ajax' => true to the PHP function call. The form submits without a page reload and supports custom JavaScript callbacks for post-submission logic. acf_form() does not support AJAX — it always does a full page reload.

Learn more about AJAX-powered ACF forms →

Can I pre-fill form fields with existing data?

Yes. Advanced Forms supports pre-filling fields programmatically, which is useful for edit forms or forms that should inherit values from the current user or post context.

Learn how to pre-fill complex fields in Advanced Forms →

Can I exclude specific fields from the frontend form?

Yes. You can exclude fields by name or key using the shortcode, PHP function, or a dynamic filter. This lets you share a field group between wp-admin and the frontend while hiding admin-only fields from frontend users.

Three ways to exclude fields in ACF frontend forms →

How does this compare to Gravity Forms or WPForms?

General-purpose form builders like Gravity Forms and WPForms have their own field systems that are separate from ACF. They work well for standalone contact forms and surveys, but if your data model is already in ACF, using a separate form builder means defining your fields twice — once in ACF for wp-admin, once in the form builder for the frontend. ACF-native approaches (acf_form or Advanced Forms) keep everything in sync automatically.

Building forms with ACF? Advanced Forms Pro gives you post/user editing, calculated fields, reCAPTCHA, and third-party integrations on top of the free version’s notifications, entries, and AJAX support. Try the free version or buy a Pro license.