function form_set_error

You are here

7 form_set_error($name = NULL, $message = '', $limit_validation_errors = NULL)
4.6 form_set_error($name, $message)
4.7 form_set_error($name = NULL, $message = '')
5 form_set_error($name = NULL, $message = '')
6 form_set_error($name = NULL, $message = '', $reset = FALSE)
8 form_set_error($name, array &$form_state, $message = '')

Files an error against a form element.

When a validation error is detected, the validator calls form_set_error() to indicate which element needs to be changed and provide an error message. This causes the Form API to not execute the form submit handlers, and instead to re-display the form to the user with the corresponding elements rendered with an 'error' CSS class (shown as red by default).

The standard form_set_error() behavior can be changed if a button provides the #limit_validation_errors property. Multistep forms not wanting to validate the whole form can set #limit_validation_errors on buttons to limit validation errors to only certain elements. For example, pressing the "Previous" button in a multistep form should not fire validation errors just because the current step has invalid values. If #limit_validation_errors is set on a clicked button, the button must also define a #submit property (may be set to an empty array). Any #submit handlers will be executed even if there is invalid input, so extreme care should be taken with respect to any actions taken by them. This is typically not a problem with buttons like "Previous" or "Add more" that do not invoke persistent storage of the submitted form values. Do not use the #limit_validation_errors property on buttons that trigger saving of form values to the database.

The #limit_validation_errors property is a list of "sections" within $form_state['values'] that must contain valid values. Each "section" is an array with the ordered set of keys needed to reach that part of $form_state['values'] (i.e., the #parents property of the element).

Example 1: Allow the "Previous" button to function, regardless of whether any user input is valid.

  $form['actions']['previous'] = array(
    '#type' => 'submit',
    '#value' => t('Previous'),
    '#limit_validation_errors' => array(),       // No validation.
    '#submit' => array('some_submit_function'),  // #submit required.

Example 2: Require some, but not all, user input to be valid to process the submission of a "Previous" button.

  $form['actions']['previous'] = array(
    '#type' => 'submit',
    '#value' => t('Previous'),
    '#limit_validation_errors' => array(
      array('step1'),       // Validate $form_state['values']['step1'].
      array('foo', 'bar'),  // Validate $form_state['values']['foo']['bar'].
    '#submit' => array('some_submit_function'), // #submit required.

This will require $form_state['values']['step1'] and everything within it (for example, $form_state['values']['step1']['choice']) to be valid, so calls to form_set_error('step1', $message) or form_set_error('step1][choice', $message) will prevent the submit handlers from running, and result in the error message being displayed to the user. However, calls to form_set_error('step2', $message) and form_set_error('step2][groupX][choiceY', $message) will be suppressed, resulting in the message not being displayed to the user, and the submit handlers will run despite $form_state['values']['step2'] and $form_state['values']['step2']['groupX']['choiceY'] containing invalid values. Errors for an invalid $form_state['values']['foo'] will be suppressed, but errors flagging invalid values for $form_state['values']['foo']['bar'] and everything within it will be flagged and submission prevented.

Partial form validation is implemented by suppressing errors rather than by skipping the input processing and validation steps entirely, because some forms have button-level submit handlers that call Drupal API functions that assume that certain data exists within $form_state['values'], and while not doing anything with that data that requires it to be valid, PHP errors would be triggered if the input processing and validation steps were fully skipped.


$name: The name of the form element. If the #parents property of your form element is array('foo', 'bar', 'baz') then you may set an error on 'foo' or 'foo][bar][baz'. Setting an error on 'foo' sets an error for every element where the #parents array starts with 'foo'.

$message: The error message to present to the user.

$limit_validation_errors: Internal use only. The #limit_validation_errors property of the clicked button, if it exists.

Return value

Return value is for internal use only. To get a list of errors, use form_get_errors() or form_get_error().

See also

Related topics

86 calls to form_set_error()
aggregator_form_category_validate in modules/aggregator/
Form validation handler for aggregator_form_category().
aggregator_form_feed_validate in modules/aggregator/
Form validation handler for aggregator_form_feed().
aggregator_form_opml_validate in modules/aggregator/
Form validation handler for aggregator_form_opml().
authorize_filetransfer_form_validate in includes/
Form validation handler for authorize_filetransfer_form().
block_add_block_form_validate in modules/block/
Form validation handler for block_add_block_form().

... See full list

1 string reference to 'form_set_error'
form_clear_error in includes/
Clears all errors against all form elements made by form_set_error().


includes/, line 1616
Functions for form and batch generation and processing.


function form_set_error($name = NULL, $message = '', $limit_validation_errors = NULL) {
  $form = &drupal_static(__FUNCTION__, array());
  $sections = &drupal_static(__FUNCTION__ . ':limit_validation_errors');
  if (isset($limit_validation_errors)) {
    $sections = $limit_validation_errors;

  if (isset($name) && !isset($form[$name])) {
    $record = TRUE;
    if (isset($sections)) {
      // #limit_validation_errors is an array of "sections" within which user
      // input must be valid. If the element is within one of these sections,
      // the error must be recorded. Otherwise, it can be suppressed.
      // #limit_validation_errors can be an empty array, in which case all
      // errors are suppressed. For example, a "Previous" button might want its
      // submit action to be triggered even if none of the submitted values are
      // valid.
      $record = FALSE;
      foreach ($sections as $section) {
        // Exploding by '][' reconstructs the element's #parents. If the
        // reconstructed #parents begin with the same keys as the specified
        // section, then the element's values are within the part of
        // $form_state['values'] that the clicked button requires to be valid,
        // so errors for this element must be recorded. As the exploded array
        // will all be strings, we need to cast every value of the section
        // array to string.
        if (array_slice(explode('][', $name), 0, count($section)) === array_map('strval', $section)) {
          $record = TRUE;
    if ($record) {
      $form[$name] = $message;
      if ($message) {
        drupal_set_message($message, 'error');

  return $form;


The main issue with this function - that exists in D6 - is NOT solved in D7. That's disappointing.

The issue:

My suggestion: make $name an array (optionally!) to make one error(message) work on several fields.

If you want the issue solved, post an issue. If you don't post an issue, the problem won't get solved.

Sorry to necro this, but here's an example in case somebody needs it.

= array( 'conditionfield1' , 'conditionfield2' );
foreach (
$error_elements as $element) :
form_set_error($element, t('Error on these elements!'));

Not a good idea. That will cause the error message to appear twice in the message area. You should do this instead:

= array('conditionfield1' , 'conditionfield2');
foreach (
$error_elements as $element) {
drupal_set_message(t('Error on these elements!'), 'error');

Also, coding standards.

Or better yet:

= array('conditionfield1' , 'conditionfield2');
form_set_error(implode('][', $element), t('Error on these elements!'));


= array('conditionfield1' , 'conditionfield2');
form_set_error(implode('][', $error_element), t('Error on these elements!'));

From my testing it seems that #limit_validation_errors appears to affect $form_state so that unvalidated fields are NOT present in $form_state['values'] but they are in $form_state['input']. I haven't seen this documented anywhere and was a strange issue to track down.

I noticed the behavior too.

I think that could be too restrictive in some cases like a "save as draft" implementation. I explain; that happens some fields are required only in publishing case and some others in both cases (draft and publishing).

The #limit_validation_errors is a great opportunity to ease the work of developers in implementing such a case with a minimum of effort, isn't it?

If you have a form that contains radio buttons, the '#limit_validation_errors' => array() parameter in a submit element has no effect for those radio elements. In other words, the form will still validate the radio elements of that form and prevent a submit. Note that it does successfully ignores the validation errors of other form element types (selects, textfields, etc.

This is particularly troublesome in "wizard" style multi-step forms where you have "previous step" buttons and you are wanting to skip validations for the step you are currently in so you can go back.

Any ideas?

I agree, I tried setting $name to NULL in the hopes of getting a general error, but it led to the error completely being ignored.

edit: in reply to rudiedirkx

To display a general form error, you can use
form_set_error('form', '...');

To de-double your error messages, use:

if (isset($_SESSION['messages']['error'])) $_SESSION['messages']['error'] = array_unique($_SESSION['messages']['error']);

Be aware that Drupal will not render any error messages for your field or mark it as having an error if the form element has no '#title'-attribute set. Instead, validation will silently fail and the user is returned to the form page with no indication of why it failed. (see

You can use this format as the first argument to target elements nested in a tree:

form_set_error('items][' . $key, 'error message');

// Example of the form elements that will be validated
$form['items'] = array('#tree' => TRUE);
$form['items'][0] = array(
'#type' => 'textfield',
$form['items'][1] = array(
'#type' => 'textfield',

Then you can set the error on an individual field within that tree like this:

// Inside your validation hook
foreach ($form_state['values']['items'] as $key => $item) {
  if (!
my_item_validator($items)) {
form_set_error('items][' . $key, t('This item failed validation');

form_set_error missing right parenthesis. should look like

form_set_error('items][' . $key, t('This item failed validation'));