How to Fix WordPress admin-ajax.php 400 Bad Request Error

If you run a WordPress website, you may have seen strange errors. The admin-ajax.php 400 Bad Request error is among the most annoying issues WordPress users encounter. It often appears without warning and can break key features of your site. Forms stop working, buttons do nothing, and even your theme might act strangely.

This error is tied to something called AJAX. AJAX allows parts of your website to update without reloading the page. WordPress uses this for things like contact forms, live search, and background tasks. The file admin-ajax.php handles these AJAX requests.

When something goes wrong with an AJAX request, WordPress may return a 400 Bad Request error. This means the server thinks the request is invalid or broken. While it sounds simple, fixing this error can be tricky. The cause might be in your code, a plugin, or even your browser.

You may wonder why one small file causes so many problems. The reason is that admin-ajax.php is used everywhere in WordPress. Many popular plugins and themes depend on it.

When this error shows up:

• AJAX forms may not submit
• Plugins might stop working
• Some admin actions fail silently
• User experience drops quickly

If your site depends on dynamic features, this can lead to lost visitors or sales.

In WordPress, many actions happen without reloading the page. Think of submitting a form, liking a post, or loading more content. AJAX, which stands for Asynchronous JavaScript and XML, is used in these features.

WordPress handles these AJAX requests through a special file called admin-ajax.php. This file is found in the /wp-admin/ folder of every WordPress site. It works in both the backend (admin area) and the frontend (user-facing side).

When your site needs to fetch or send data without reloading, it sends a request to this file. The file then tells WordPress how to handle the task.

This file is like a traffic controller for AJAX tasks. It handles every request and directs it to the correct function in your theme or plugin.

Here are some common features that use it:

• Contact forms
• Live search bars
• “Load more” buttons
• WooCommerce add-to-cart buttons
• Auto-save in the post editor

Without admin-ajax.php, many of these would stop working.

Every AJAX request sent to WordPress must call admin-ajax.php. It also needs to include a parameter called “action”. This tells WordPress which function to run.

For example, a form might send this:

/wp-admin/admin-ajax.php?action=submit_form

Then WordPress looks for a function linked to ‘submit_form’.

There are two types of AJAX hooks used:

• wp_ajax_{action} – for logged-in users
• wp_ajax_nopriv_{action} – for logged-out users

If you use the wrong hook, the request can fail. That’s when you might see the admin-ajax.php 400 Bad Request error.

The admin-ajax.php 400 Bad Request error happens when WordPress receives a broken or incomplete request. This typically indicates that there is a problem with the way AJAX is sending data to the server. This can happen for a variety of reasons, and the first step in resolving it is determining the precise cause.

Let’s take a closer look at the most frequent reasons.

1. Malformed AJAX Request

A malformed AJAX request is built incorrectly. When a script sends data to the server, it must follow a proper format. The server might not understand if something is missing or not in its proper place.

For example, if a plugin sends an AJAX request with missing or improperly formatted parameters, WordPress might return a 400 error.

Malformed requests may be caused by:

• JavaScript bugs in your theme or plugin
• Using incorrect syntax when building the request
• Encoding errors in the data payload

This issue often arises during custom development or when using outdated plugins.

2. Missing Action Parameter

Every request in WordPress AJAX needs to contain a “action” parameter. This tells WordPress which function to run on the server side.

If the action parameter is missing, empty, or misspelled, WordPress won’t know what to do with the request. Consequently, a 400 Bad Request error is returned.

For instance, a request like this:

jQuery.post(ajaxurl, { name: ‘John’ });

Will fail because it lacks the required action field. The correct version should look like:

jQuery.post(ajaxurl, { action: ‘my_custom_function’, name: ‘John’ });

Even a small typo in the action name can break the request.

3. Incorrect AJAX URL

The target URL for all AJAX calls in WordPress should be:

/wp-admin/admin-ajax.php

If this URL is hardcoded incorrectly, or if a plugin points the request to another location, the server won’t recognize the call. This can result in a 400 error.

Some common causes:

• Manually editing AJAX URLs in JavaScript
• Using incorrect ajaxurl in the frontend
• CDN or caching plugins modifying the URL

Always use admin_url(‘admin-ajax.php’) in PHP or the global ajaxurl variable in JavaScript to ensure the correct path is used.

4. wp_ajax vs wp_ajax_nopriv Hook Misuse

WordPress provides two types of AJAX hooks:

• wp_ajax_{action} – For logged-in users
• wp_ajax_nopriv_{action} – For non-logged-in users

If your site only uses one of these and not the other, your AJAX request may fail depending on who sends it.

For example, if a visitor (logged out) clicks a button that sends an AJAX request, and you’ve only set up wp_ajax_{action}, WordPress won’t respond correctly. This mismatch leads to a 400 error.

Developers often forget to register both hooks when creating public-facing features.

5. Plugin or Theme Conflicts

Sometimes a plugin or theme tries to run an AJAX call that another plugin or the theme itself is also handling. This can lead to unexpected results.

Conflicts can happen when:

• Multiple plugins register the same AJAX action name
• Scripts send different data structures to the same action
• JavaScript is outdated or loaded in the wrong order

These conflicts often produce broken requests, leading to the 400 error. Debugging tools like your browser’s developer console can help detect where the request is going wrong.

6. Large File Uploads via AJAX

Uploading files through AJAX works well — until the files get too big.

WordPress and your server both have limits on how large a file can be. If your AJAX request tries to send a file that exceeds these limits, the server may reject it.

Key PHP settings that affect this include:

• upload_max_filesize
• post_max_size
• max_input_vars

When the data is too large, the server fails to process the request and returns a 400 Bad Request.

Now that you know the possible causes of the admin-ajax.php 400 Bad Request error, it’s time to fix it. In this section, we’ll walk through each fix in a simple, clear way. To follow these procedures, you don’t have to be a developer.

Let’s get started.

1. Clear Browser Cache and Cookies

Your browser may occasionally save outdated information that conflicts with AJAX queries. A quick and simple solution is to clear the cache and cookies.

Steps to clear browser cache:

• Open your browser (Chrome, Firefox, or Safari)
• Press Ctrl + Shift + Delete (or Cmd + Shift + Delete on Mac)
• Choose “All time” for the time range
• Check the boxes for “Cached images and files” and “Cookies”
• Click Clear Data

After clearing, reload your WordPress site and try again. If you recently upgraded plugins or made script modifications, this repair is quite helpful.

2. Check for Incorrect AJAX URL

AJAX requests must be sent to the correct URL. In WordPress, this should be:

/wp-admin/admin-ajax.php

Using the wrong URL will trigger a 400 error. This is common when developers hardcode the URL instead of using WordPress functions.

How to fix:

• In your JavaScript code, always use the ajaxurl variable
• In PHP, use admin_url(‘admin-ajax.php’) to get the correct path
• Avoid typing the full URL manually

Example (JavaScript):

jQuery.post(ajaxurl, {

  action: ‘my_function’,

  data: ‘example’

});

This ensures the request always goes to the right place, even if your domain or site path changes.

3. Use Developer Tools to Inspect AJAX Requests

Most modern browsers have tools to inspect AJAX activity. These tools can show exactly what data is being sent and returned.

Steps using Chrome DevTools:

• Open your site in Chrome
• Press F12 to open Developer Tools
• Click the “Network” tab
• Filter by “XHR” to see AJAX requests
• Click on the failing request
• Check the Headers, Payload, and Response tabs

Look for signs like:

• Missing action name
• Incorrect content-type (e.g., not JSON)
• Response message saying “Bad Request”

This helps pinpoint whether the problem is in the request or response.

4. Add the Missing Action Parameter

Every AJAX request must include an action. This tells WordPress which function to run.

What to check:

• Make sure action is included in your request
• Ensure the action name matches the one used in your functions.php or plugin file
• Double-check spelling and case (it’s case-sensitive)

Example (Correct):

jQuery.post(ajaxurl, {

  action: ‘submit_contact_form’,

  name: ‘John’

});

If this parameter is missing, WordPress doesn’t know which function to trigger, and a 400 error will occur.

5. Fix Hook Usage: wp_ajax vs wp_ajax_nopriv

In WordPress, there are two types of AJAX hooks:

• wp_ajax_{action} – for logged-in users
• wp_ajax_nopriv_{action} – for logged-out visitors

If you’re building a public-facing feature (like a contact form), and only use wp_ajax_{action}, visitors will get a 400 error.

How to register both hooks:

add_action(‘wp_ajax_submit_contact_form’, ‘handle_contact_form’);

add_action(‘wp_ajax_nopriv_submit_contact_form’, ‘handle_contact_form’);

This makes sure the function runs no matter who sends the request.

6. Deactivate Plugins to Check for Conflicts

A plugin may be sending broken AJAX requests or interfering with the action hooks.

How to test:

• Go to your WordPress dashboard
• Navigate to Plugins > Installed Plugins
• Deactivate all plugins
• Test the AJAX feature again

If the error disappears, one of your plugins is the problem. One by one, reactivate each plugin while testing.

Once the error returns, you’ll know which plugin is causing the issue.

Tip: Use a staging site or enable “Troubleshooting Mode” with the Health Check & Troubleshooting plugin to avoid breaking the live site.

7. Fix Large File Upload Settings

If your AJAX request involves uploading a file, make sure your server can handle the size.

Common issues:

• File exceeds upload size limits
• Server blocks large POST requests
• Timeout due to slow connection

How to check and fix (via php.ini or .htaccess):

• upload_max_filesize = 64M
• post_max_size = 64M
• max_input_time = 300
• max_execution_time = 300

After increasing these values, restart your server or contact your hosting provider for help. Also make sure your plugin or theme doesn’t have additional limits set in its code.

Fixing the error is important, but preventing it is even better. The likelihood of encountering the admin-ajax.php 400 Bad Request problem again can be decreased by adhering to a few best practices.

Here are a few easy yet efficient ways to maintain an error-free website.

1. Always Use the Correct AJAX URL

Never hardcode the admin-ajax URL. WordPress provides safe and flexible ways to call it.

Use this in PHP:

echo admin_url(‘admin-ajax.php’);

Use this in JavaScript:
 Use the ajaxurl variable that WordPress defines for you.

This ensures the request goes to the correct file, even if your site URL changes.

2. Use Both wp_ajax and wp_ajax_nopriv Hooks

Make sure to register AJAX actions for both logged-in and logged-out users. Forgetting one can break your feature for some users.

Example:

add_action(‘wp_ajax_my_action’, ‘my_function’);

add_action(‘wp_ajax_nopriv_my_action’, ‘my_function’);

This handles requests from everyone.

3. Validate and Sanitize Input Data

Always check and clean the data you receive in your functions. This prevents malformed requests and protects your site from attacks.

Use WordPress functions like:

• sanitize_text_field()
• esc_html()
• check_ajax_referer()

These functions ensure the request is safe and complete.

4. Keep Your Plugins and Themes Updated

AJAX problems might be caused by issues in outdated plugins or themes. Always update them to the latest versions. This includes:

• WordPress core
• Active plugins
• Your theme and child theme

Updates often include security fixes and improved compatibility.

5. Test New Features on a Staging Site

Avoid testing new code or plugins on your live website. For early error detection, use a staging environment.

This keeps your live site stable and error-free.

Handling WordPress errors can be stressful, especially when they break important features. You shouldn’t have to spend hours debugging confusing AJAX issues alone. If you’re still facing problems or want to make sure your site is running smoothly, expert help is just a click away.

At 24×7 WP Support, our team is available around the clock to fix WordPress errors, optimize performance, and secure your site. Whether it’s a broken AJAX function or a hidden plugin conflict, we solve it fast and professionally.

👉 Contact 24×7 WP Support today and get instant help from certified WordPress experts. We’re here when you need us — anytime, anywhere.