diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index fd26aafb..b5d3f767 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -8,6 +8,53 @@ Features:
 
 * Add ``force_all`` argument to ``use_args`` and ``use_kwargs``
   (:issue:`252`, :issue:`307`). Thanks :user:`piroux` for reporting.
+* The ``status_code`` and ``headers`` arguments to ``ValidationError``
+  are deprecated. Pass ``error_status_code`` and ``error_headers`` to
+  `Parser.parse`, `Parser.use_args`, and `Parser.use_kwargs` instead.
+  (:issue:`327`, :issue:`336`).
+* Custom error handlers receive ``error_status_code`` and ``error_headers`` arguments.
+  (:issue:`327`).
+
+.. code-block:: python
+
+    # <4.2.0
+    @parser.error_handler
+    def handle_error(error, req, schema):
+        raise CustomError(error.messages)
+
+
+    class MyParser(FlaskParser):
+        def handle_error(self, error, req, schema):
+            # ...
+            raise CustomError(error.messages)
+
+
+    # >=4.2.0
+    @parser.error_handler
+    def handle_error(error, req, schema, status_code, headers):
+        raise CustomError(error.messages)
+
+
+    # OR
+
+
+    @parser.error_handler
+    def handle_error(error, **kwargs):
+        raise CustomError(error.messages)
+
+
+    class MyParser(FlaskParser):
+        def handle_error(self, error, req, schema, status_code, headers):
+            # ...
+            raise CustomError(error.messages)
+
+        # OR
+
+        def handle_error(self, error, req, **kwargs):
+            # ...
+            raise CustomError(error.messages)
+
+Legacy error handlers will be supported until version 5.0.0.
 
 4.1.3 (2018-12-02)
 ******************
diff --git a/docs/quickstart.rst b/docs/quickstart.rst
index aeb5b330..ac662cc6 100644
--- a/docs/quickstart.rst
+++ b/docs/quickstart.rst
@@ -200,7 +200,7 @@ Then decorate that function with :func:`Parser.error_handler <webargs.core.Parse
 
 
     @parser.error_handler
-    def handle_error(error, req, schema):
+    def handle_error(error, req, schema, status_code, headers):
         raise CustomError(error.messages)
 
 Nesting Fields
diff --git a/examples/flask_example.py b/examples/flask_example.py
index b9e215b9..66e30fc2 100644
--- a/examples/flask_example.py
+++ b/examples/flask_example.py
@@ -35,7 +35,7 @@ def index(args):
 
 
 @app.route("/add", methods=["POST"])
-@use_kwargs(add_args)
+@use_kwargs(add_args, error_status_code=400)
 def add(x, y):
     """An addition endpoint."""
     return jsonify({"result": x + y})
@@ -63,6 +63,7 @@ def dateadd(value, addend, unit):
 
 # Return validation errors as JSON
 @app.errorhandler(422)
+@app.errorhandler(400)
 def handle_validation_error(err):
     exc = getattr(err, "exc", None)
     if exc:
diff --git a/tests/apps/flask_app.py b/tests/apps/flask_app.py
index 0a1b7d27..db960be4 100644
--- a/tests/apps/flask_app.py
+++ b/tests/apps/flask_app.py
@@ -184,4 +184,4 @@ def echo_use_kwargs_missing(username, password):
 @app.errorhandler(422)
 def handle_validation_error(err):
     assert isinstance(err.data["schema"], ma.Schema)
-    return J({"errors": err.exc.messages}), 422
+    return J({"errors": err.exc.messages}), err.code
diff --git a/tests/test_core.py b/tests/test_core.py
index 8ded40fd..7280aeba 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -24,6 +24,13 @@
 strict_kwargs = {"strict": True} if MARSHMALLOW_VERSION_INFO[0] < 3 else {}
 
 
+class MockHTTPError(Exception):
+    def __init__(self, status_code, headers):
+        self.status_code = status_code
+        self.headers = headers
+        super(MockHTTPError, self).__init__(self, "HTTP Error occurred")
+
+
 class MockRequestParser(Parser):
     """A minimal parser implementation that parses mock requests."""
 
@@ -999,12 +1006,14 @@ def validate(value):
 
 
 class TestValidationError:
-    def test_can_store_status_code(self):
-        err = ValidationError("foo", status_code=401)
+    def test_status_code_is_deprecated(self):
+        with pytest.warns(DeprecationWarning):
+            err = ValidationError("foo", status_code=401)
         assert err.status_code == 401
 
-    def test_can_store_headers(self):
-        err = ValidationError("foo", headers={"X-Food-Header": "pizza"})
+    def test_headers_is_deprecated(self):
+        with pytest.warns(DeprecationWarning):
+            err = ValidationError("foo", headers={"X-Food-Header": "pizza"})
         assert err.headers == {"X-Food-Header": "pizza"}
 
     def test_str(self):
@@ -1101,3 +1110,25 @@ def test_get_mimetype():
     assert get_mimetype("application/json") == "application/json"
     assert get_mimetype("application/json;charset=utf8") == "application/json"
     assert get_mimetype(None) is None
+
+
+class MockRequestParserWithErrorHandler(MockRequestParser):
+    def handle_error(
+        self, error, req, schema, error_status_code=None, error_headers=None
+    ):
+        assert isinstance(error, ValidationError)
+        assert isinstance(schema, Schema)
+        raise MockHTTPError(error_status_code, error_headers)
+
+
+def test_parse_with_error_status_code_and_headers(web_request):
+    parser = MockRequestParserWithErrorHandler()
+    web_request.json = {"foo": 42}
+    args = {"foo": fields.Field(validate=lambda x: False)}
+    with pytest.raises(MockHTTPError) as excinfo:
+        parser.parse(
+            args, web_request, error_status_code=418, error_headers={"X-Foo": "bar"}
+        )
+    error = excinfo.value
+    assert error.status_code == 418
+    assert error.headers == {"X-Foo": "bar"}
diff --git a/webargs/aiohttpparser.py b/webargs/aiohttpparser.py
index 4de4da4d..161e0b2f 100644
--- a/webargs/aiohttpparser.py
+++ b/webargs/aiohttpparser.py
@@ -140,9 +140,9 @@ def get_request_from_view_args(self, view, args, kwargs):
         assert isinstance(req, web.Request), "Request argument not found for handler"
         return req
 
-    def handle_error(self, error, req, schema):
+    def handle_error(self, error, req, schema, error_status_code, error_headers):
         """Handle ValidationErrors and return a JSON response of error messages to the client."""
-        error_class = exception_map.get(error.status_code)
+        error_class = exception_map.get(error_status_code or error.status_code)
         if not error_class:
             raise LookupError("No exception for {0}".format(error.status_code))
         raise error_class(
diff --git a/webargs/asyncparser.py b/webargs/asyncparser.py
index ceb9d3ba..91558435 100644
--- a/webargs/asyncparser.py
+++ b/webargs/asyncparser.py
@@ -57,7 +57,14 @@ async def _parse_request(self, schema, req, locations):
 
     # TODO: Lots of duplication from core.Parser here. Rethink.
     async def parse(
-        self, argmap, req=None, locations=None, validate=None, force_all=False
+        self,
+        argmap,
+        req=None,
+        locations=None,
+        validate=None,
+        force_all=False,
+        error_status_code=None,
+        error_headers=None,
     ):
         """Coroutine variant of `webargs.core.Parser`.
 
@@ -76,7 +83,9 @@ async def parse(
             data = result.data if core.MARSHMALLOW_VERSION_INFO[0] < 3 else result
             self._validate_arguments(data, validators)
         except ma.exceptions.ValidationError as error:
-            self._on_validation_error(error, req, schema)
+            self._on_validation_error(
+                error, req, schema, error_status_code, error_headers
+            )
         finally:
             self.clear_cache()
         if force_all:
@@ -91,6 +100,8 @@ def use_args(
         as_kwargs=False,
         validate=None,
         force_all=None,
+        error_status_code=None,
+        error_headers=None,
     ):
         """Decorator that injects parsed arguments into a view function or method.
 
@@ -122,6 +133,8 @@ async def wrapper(*args, **kwargs):
                         locations=locations,
                         validate=validate,
                         force_all=force_all_,
+                        error_status_code=error_status_code,
+                        error_headers=error_headers,
                     )
                     if as_kwargs:
                         kwargs.update(parsed_args)
@@ -146,6 +159,8 @@ def wrapper(*args, **kwargs):
                         locations=locations,
                         validate=validate,
                         force_all=force_all_,
+                        error_status_code=error_status_code,
+                        error_headers=error_headers,
                     )
                     if as_kwargs:
                         kwargs.update(parsed_args)
diff --git a/webargs/bottleparser.py b/webargs/bottleparser.py
index ada807b2..50cab749 100644
--- a/webargs/bottleparser.py
+++ b/webargs/bottleparser.py
@@ -57,12 +57,14 @@ def parse_files(self, req, name, field):
         """Pull a file from the request."""
         return core.get_value(req.files, name, field)
 
-    def handle_error(self, error, req, schema):
+    def handle_error(self, error, req, schema, error_status_code, error_headers):
         """Handles errors during parsing. Aborts the current request with a
         400 error.
         """
-        status_code = getattr(error, "status_code", self.DEFAULT_VALIDATION_STATUS)
-        headers = getattr(error, "headers", {})
+        status_code = error_status_code or getattr(
+            error, "status_code", self.DEFAULT_VALIDATION_STATUS
+        )
+        headers = error_headers or getattr(error, "headers", {})
         raise bottle.HTTPError(
             status=status_code, body=error.messages, headers=headers, exception=error
         )
diff --git a/webargs/core.py b/webargs/core.py
index 8a1622ce..b4207edc 100755
--- a/webargs/core.py
+++ b/webargs/core.py
@@ -31,6 +31,30 @@
     "parse_json",
 ]
 
+
+# Copied from marshmallow.utils
+def _signature(func):
+    if hasattr(inspect, "signature"):
+        return list(inspect.signature(func).parameters.keys())
+    if hasattr(func, "__self__"):
+        # Remove bound arg to match inspect.signature()
+        return inspect.getargspec(func).args[1:]
+    # All args are unbound
+    return inspect.getargspec(func).args
+
+
+def get_func_args(func):
+    """Given a callable, return a tuple of argument names. Handles
+    `functools.partial` objects and class-based callables.
+    """
+    if isinstance(func, functools.partial):
+        return _signature(func.func)
+    if inspect.isfunction(func) or inspect.ismethod(func):
+        return _signature(func)
+    # Callable class
+    return _signature(func.__call__)
+
+
 MARSHMALLOW_VERSION_INFO = tuple(LooseVersion(ma.__version__).version)
 
 DEFAULT_VALIDATION_STATUS = 422
@@ -43,15 +67,32 @@ class WebargsError(Exception):
 
 
 class ValidationError(WebargsError, ma.exceptions.ValidationError):
-    """Raised when validation fails on user input. Same as
-    `marshmallow.ValidationError`, with the addition of the ``status_code`` and
-    ``headers`` arguments.
+    """Raised when validation fails on user input.
+
+    .. versionchanged:: 4.2.0
+        status_code and headers arguments are deprecated. Pass
+        error_status_code and error_headers to `Parser.parse`,
+        `Parser.use_args`, and `Parser.use_kwargs` instead.
     """
 
-    def __init__(
-        self, message, status_code=DEFAULT_VALIDATION_STATUS, headers=None, **kwargs
-    ):
-        self.status_code = status_code
+    def __init__(self, message, status_code=None, headers=None, **kwargs):
+        if status_code is not None:
+            warnings.warn(
+                "The status_code argument to ValidationError is deprecated "
+                "and will be removed in 5.0.0. "
+                "Pass error_status_code to Parser.parse, Parser.use_args, "
+                "or Parser.use_kwargs instead.",
+                DeprecationWarning,
+            )
+        self.status_code = status_code or DEFAULT_VALIDATION_STATUS
+        if headers is not None:
+            warnings.warn(
+                "The headers argument to ValidationError is deprecated "
+                "and will be removed in 5.0.0. "
+                "Pass error_headers to Parser.parse, Parser.use_args, "
+                "or Parser.use_kwargs instead.",
+                DeprecationWarning,
+            )
         self.headers = headers
         ma.exceptions.ValidationError.__init__(
             self, message, status_code=status_code, headers=headers, **kwargs
@@ -316,7 +357,9 @@ def _parse_request(self, schema, req, locations):
                     parsed[argname] = parsed_value
         return parsed
 
-    def _on_validation_error(self, error, req, schema):
+    def _on_validation_error(
+        self, error, req, schema, error_status_code, error_headers
+    ):
         if isinstance(error, ma.exceptions.ValidationError) and not isinstance(
             error, ValidationError
         ):
@@ -333,9 +376,27 @@ def _on_validation_error(self, error, req, schema):
                 kwargs["status_code"] = self.DEFAULT_VALIDATION_STATUS
             error = ValidationError(error.messages, **kwargs)
         if self.error_callback:
-            self.error_callback(error, req, schema)
+            if len(get_func_args(self.error_callback)) > 3:
+                self.error_callback(
+                    error, req, schema, error_status_code, error_headers
+                )
+            else:  # Backwards compat with webargs<=4.2.0
+                warnings.warn(
+                    "Error handler functions should include error_status_code and "
+                    "error_headers args, or include **kwargs in the signature",
+                    DeprecationWarning,
+                )
+                self.error_callback(error, req, schema)
         else:
-            self.handle_error(error, req, schema)
+            if len(get_func_args(self.handle_error)) > 3:
+                self.handle_error(error, req, schema, error_status_code, error_headers)
+            else:
+                warnings.warn(
+                    "handle_error methods should include error_status_code and "
+                    "error_headers args, or include **kwargs in the signature",
+                    DeprecationWarning,
+                )
+                self.handle_error(error, req, schema)
 
     def _validate_arguments(self, data, validators):
         for validator in validators:
@@ -368,7 +429,16 @@ def _get_schema(self, argmap, req):
             )
         return schema
 
-    def parse(self, argmap, req=None, locations=None, validate=None, force_all=False):
+    def parse(
+        self,
+        argmap,
+        req=None,
+        locations=None,
+        validate=None,
+        force_all=False,
+        error_status_code=None,
+        error_headers=None,
+    ):
         """Main request parsing method.
 
         :param argmap: Either a `marshmallow.Schema`, a `dict`
@@ -381,6 +451,12 @@ def parse(self, argmap, req=None, locations=None, validate=None, force_all=False
         :param callable validate: Validation function or list of validation functions
             that receives the dictionary of parsed arguments. Validator either returns a
             boolean or raises a :exc:`ValidationError`.
+        :param bool force_all: If `True`, missing arguments will be replaced with
+            `missing <marshmallow.utils.missing>`.
+        :param int error_status_code: Status code passed to error handler functions when
+            a `ValidationError` is raised.
+        :param dict error_headers: Headers passed to error handler functions when a
+            a `ValidationError` is raised.
 
          :return: A dictionary of parsed arguments
         """
@@ -395,7 +471,9 @@ def parse(self, argmap, req=None, locations=None, validate=None, force_all=False
             data = result.data if MARSHMALLOW_VERSION_INFO[0] < 3 else result
             self._validate_arguments(data, validators)
         except ma.exceptions.ValidationError as error:
-            self._on_validation_error(error, req, schema)
+            self._on_validation_error(
+                error, req, schema, error_status_code, error_headers
+            )
         finally:
             self.clear_cache()
         if force_all:
@@ -435,6 +513,8 @@ def use_args(
         as_kwargs=False,
         validate=None,
         force_all=None,
+        error_status_code=None,
+        error_headers=None,
     ):
         """Decorator that injects parsed arguments into a view function or method.
 
@@ -482,6 +562,8 @@ def wrapper(*args, **kwargs):
                     locations=locations,
                     validate=validate,
                     force_all=force_all_,
+                    error_status_code=error_status_code,
+                    error_headers=error_headers,
                 )
                 if as_kwargs:
                     kwargs.update(parsed_args)
@@ -539,8 +621,9 @@ def decorator(func):
 
     def error_handler(self, func):
         """Decorator that registers a custom error handling function. The
-        function should received the raised error, request object, and the
-        `marshmallow.Schema` instance used to parse the request. Overrides
+        function should receive the raised error, request object,
+        `marshmallow.Schema` instance used to parse the request, error status code,
+        and headers to use for the error response. Overrides
         the parser's ``handle_error`` method.
 
         Example: ::
@@ -555,7 +638,7 @@ class CustomError(Exception):
 
 
             @parser.error_handler
-            def handle_error(error, req, schema):
+            def handle_error(error, req, schema, status_code, headers):
                 raise CustomError(error.messages)
 
         :param callable func: The error callback to register.
@@ -601,7 +684,9 @@ def parse_files(self, req, name, arg):
         """
         return missing
 
-    def handle_error(self, error, req, schema):
+    def handle_error(
+        self, error, req, schema, error_status_code=None, error_headers=None
+    ):
         """Called if an error occurs while parsing args. By default, just logs and
         raises ``error``.
         """
diff --git a/webargs/falconparser.py b/webargs/falconparser.py
index 3a88a67c..705fcf1e 100644
--- a/webargs/falconparser.py
+++ b/webargs/falconparser.py
@@ -140,9 +140,9 @@ def parse_files(self, req, name, field):
             "Parsing files not yet supported by {0}".format(self.__class__.__name__)
         )
 
-    def handle_error(self, error, req, schema):
+    def handle_error(self, error, req, schema, error_status_code, error_headers):
         """Handles errors during parsing."""
-        status = status_map.get(error.status_code)
+        status = error_status_code or status_map.get(error.status_code)
         if status is None:
             raise LookupError("Status code {0} not supported".format(error.status_code))
         raise HTTPError(status, errors=error.messages)
diff --git a/webargs/flaskparser.py b/webargs/flaskparser.py
index e1136e60..0405b441 100644
--- a/webargs/flaskparser.py
+++ b/webargs/flaskparser.py
@@ -93,11 +93,13 @@ def parse_files(self, req, name, field):
         """Pull a file from the request."""
         return core.get_value(req.files, name, field)
 
-    def handle_error(self, error, req, schema):
+    def handle_error(self, error, req, schema, error_status_code, error_headers):
         """Handles errors during parsing. Aborts the current HTTP request and
         responds with a 422 error.
         """
-        status_code = getattr(error, "status_code", self.DEFAULT_VALIDATION_STATUS)
+        status_code = error_status_code or getattr(
+            error, "status_code", self.DEFAULT_VALIDATION_STATUS
+        )
         abort(status_code, exc=error, messages=error.messages, schema=schema)
 
     def get_default_request(self):
diff --git a/webargs/pyramidparser.py b/webargs/pyramidparser.py
index 98dbb6f8..556a9ff3 100644
--- a/webargs/pyramidparser.py
+++ b/webargs/pyramidparser.py
@@ -73,11 +73,11 @@ def parse_matchdict(self, req, name, field):
         """Pull a value from the request's `matchdict`."""
         return core.get_value(req.matchdict, name, field)
 
-    def handle_error(self, error, req, schema):
+    def handle_error(self, error, req, schema, error_status_code, error_headers):
         """Handles errors during parsing. Aborts the current HTTP request and
         responds with a 400 error.
         """
-        status_code = getattr(error, "status_code", 422)
+        status_code = error_status_code or getattr(error, "status_code", 422)
         raise exception_response(status_code, detail=text_type(error))
 
     def use_args(
diff --git a/webargs/tornadoparser.py b/webargs/tornadoparser.py
index d74579a6..24a2fe89 100644
--- a/webargs/tornadoparser.py
+++ b/webargs/tornadoparser.py
@@ -113,11 +113,13 @@ def parse_files(self, req, name, field):
         """Pull a file from the request."""
         return get_value(req.files, name, field)
 
-    def handle_error(self, error, req, schema):
+    def handle_error(self, error, req, schema, error_status_code, error_headers):
         """Handles errors during parsing. Raises a `tornado.web.HTTPError`
         with a 400 error.
         """
-        status_code = getattr(error, "status_code", core.DEFAULT_VALIDATION_STATUS)
+        status_code = error_status_code or getattr(
+            error, "status_code", core.DEFAULT_VALIDATION_STATUS
+        )
         if status_code == 422:
             reason = "Unprocessable Entity"
         else: