diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# 0.2.0.0
+
+- Make `withRecovery` rewind before running recovery
+
 # 0.1.0.4
 
 - Add `Generic` instances to `Span` and `Position`
diff --git a/parsix.cabal b/parsix.cabal
--- a/parsix.cabal
+++ b/parsix.cabal
@@ -1,5 +1,5 @@
 name:                parsix
-version:             0.1.0.4
+version:             0.2.0.0
 synopsis:            Parser combinators with slicing, error recovery, and syntax highlighting
 description:         A parser combinator library based on 'parsers' (like 'trifecta') with slicing, error recovery, and syntax highlighted diagnostics
 homepage:            https://github.com/ollef/parsix
diff --git a/src/Text/Parsix/Combinators.hs b/src/Text/Parsix/Combinators.hs
--- a/src/Text/Parsix/Combinators.hs
+++ b/src/Text/Parsix/Combinators.hs
@@ -45,14 +45,14 @@
 sliced = slicedWith (\_ t -> t)
 
 class Parsing m => RecoveryParsing m where
-  withRecovery :: (ErrorInfo -> m a) -> m a -> m a
+  withRecovery :: (ErrorInfo -> Position -> m a) -> m a -> m a
 
 instance RecoveryParsing Parser where
   withRecovery recover (Parser p) = Parser
     $ \s0 s e0 e pos hl inp -> p
       s0
       s
-      (\err -> unParser (recover err)
+      (\err -> unParser (recover err pos)
         (\a _err' -> s0 a err)
         s
         (\_err' -> e0 err)
@@ -60,13 +60,13 @@
         pos
         hl
         inp)
-      (\err pos' hl' -> unParser (recover err)
-        (\a _err' -> s a err pos' hl')
+      (\err pos' hl' -> unParser (recover err pos')
+        (\a _err' -> s a err pos hl)
         s
         (\_err' -> e err pos' hl')
         (\_err' _pos'' _hl'' -> e err pos' hl')
-        pos'
-        hl'
+        pos
+        hl
         inp)
       pos
       hl
@@ -127,39 +127,39 @@
 instance (RecoveryParsing m, MonadPlus m) => RecoveryParsing (Lazy.StateT s m) where
   withRecovery r (Lazy.StateT m)
     = Lazy.StateT
-    $ \s -> withRecovery (\err -> Lazy.runStateT (r err) s) (m s)
+    $ \s -> withRecovery (\err pos -> Lazy.runStateT (r err pos) s) (m s)
 
 instance (RecoveryParsing m, MonadPlus m) => RecoveryParsing (Strict.StateT s m) where
   withRecovery r (Strict.StateT m)
     = Strict.StateT
-    $ \s -> withRecovery (\err -> Strict.runStateT (r err) s) (m s)
+    $ \s -> withRecovery (\err pos -> Strict.runStateT (r err pos) s) (m s)
 
 instance (RecoveryParsing m, MonadPlus m) => RecoveryParsing (ReaderT e m) where
   withRecovery r (ReaderT m)
     = ReaderT
-    $ \s -> withRecovery (\err -> runReaderT (r err) s) (m s)
+    $ \s -> withRecovery (\err pos -> runReaderT (r err pos) s) (m s)
 
 instance (RecoveryParsing m, MonadPlus m, Monoid w) => RecoveryParsing (Strict.WriterT w m) where
   withRecovery r (Strict.WriterT m)
     = Strict.WriterT
-    $ withRecovery (Strict.runWriterT . r) m
+    $ withRecovery (\err pos -> Strict.runWriterT $ r err pos) m
 
 instance (RecoveryParsing m, MonadPlus m, Monoid w) => RecoveryParsing (Lazy.WriterT w m) where
   withRecovery r (Lazy.WriterT m)
     = Lazy.WriterT
-    $ withRecovery (Lazy.runWriterT . r) m
+    $ withRecovery (\err pos -> Lazy.runWriterT $ r err pos) m
 
 instance (RecoveryParsing m, MonadPlus m, Monoid w) => RecoveryParsing (Lazy.RWST r w s m) where
   withRecovery r (Lazy.RWST m)
     = Lazy.RWST
-    $ \s s' -> withRecovery (\err -> Lazy.runRWST (r err) s s') (m s s')
+    $ \s s' -> withRecovery (\err pos -> Lazy.runRWST (r err pos) s s') (m s s')
 
 instance (RecoveryParsing m, MonadPlus m, Monoid w) => RecoveryParsing (Strict.RWST r w s m) where
   withRecovery r (Strict.RWST m)
     = Strict.RWST
-    $ \s s' -> withRecovery (\err -> Strict.runRWST (r err) s s') (m s s')
+    $ \s s' -> withRecovery (\err pos -> Strict.runRWST (r err pos) s s') (m s s')
 
 instance (RecoveryParsing m, MonadPlus m) => RecoveryParsing (IdentityT m) where
   withRecovery r (IdentityT m)
     = IdentityT
-    $ withRecovery (runIdentityT . r) m
+    $ withRecovery (\err pos -> runIdentityT $ r err pos) m
diff --git a/tests/WithRecovery.hs b/tests/WithRecovery.hs
--- a/tests/WithRecovery.hs
+++ b/tests/WithRecovery.hs
@@ -8,20 +8,23 @@
 tests = testGroup "withRecovery"
   [ testProperty "inner epsilon success"
     $ \xs -> success (== Just ())
-    $ parse (withRecovery (\_ -> pure Nothing) (pure (Just ()))) xs
+    $ parse (withRecovery (\_ _ -> pure Nothing) (pure (Just ()))) xs
   , testProperty "inner committed success"
     $ \x -> success (== Just x)
-    $ parse (withRecovery (\_ -> pure Nothing) (Just <$> char x)) [x]
+    $ parse (withRecovery (\_ _ -> pure Nothing) (Just <$> char x)) [x]
   , testProperty "inner epsilon error"
     $ \x y -> x /= y ==> success (== Nothing)
-    $ parse (withRecovery (\_ -> pure Nothing) (Just <$> char x)) [y]
+    $ parse (withRecovery (\_ _ -> pure Nothing) (Just <$> char x)) [y]
   , testProperty "inner committed error"
     $ \x y -> x /= y ==> success (== Nothing)
-    $ parse (withRecovery (\_ -> pure Nothing) (Just <$> char x <* char x)) [x, y]
+    $ parse (withRecovery (\_ _ -> pure Nothing) (Just <$> char x <* char x)) [x, y]
   , testProperty "recover epsilon error"
     $ \x y -> x /= y ==> failure (atPosition 1)
-    $ parse (withRecovery (\_ -> empty) (Just <$> char x <* char x)) [x, y]
+    $ parse (withRecovery (\_ _ -> empty) (Just <$> char x <* char x)) [x, y]
   , testProperty "recover committed error"
     $ \x y z -> x /= y && y /= z ==> failure (atPosition 1)
-    $ parse (withRecovery (\_ -> Nothing <$ char y <* char y) (Just <$> char x <* char x)) [x, y, z]
+    $ parse (withRecovery (\_ _ -> Nothing <$ char y <* char y) (Just <$> char x <* char x)) [x, y, z]
+  , testProperty "recovery runs from start"
+    $ \x y -> x /= y ==> success (== Just x)
+    $ parse (withRecovery (\_ _ -> Just <$> char x <* char y) (Just <$> char x <* char x)) [x, y]
   ]