diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# 0.0.1.8
+
+- Added strict variant of the `foldMapWithKey` function.
+
 # 0.0.1.7
 
 - Added a selection of folding operations for `MonoidMap`.
diff --git a/monoidmap.cabal b/monoidmap.cabal
--- a/monoidmap.cabal
+++ b/monoidmap.cabal
@@ -1,6 +1,6 @@
 cabal-version:  3.0
 name:           monoidmap
-version:        0.0.1.7
+version:        0.0.1.8
 bug-reports:    https://github.com/jonathanknowles/monoidmap/issues
 license:        Apache-2.0
 license-file:   LICENSE
diff --git a/src/internal/Data/MonoidMap/Internal.hs b/src/internal/Data/MonoidMap/Internal.hs
--- a/src/internal/Data/MonoidMap/Internal.hs
+++ b/src/internal/Data/MonoidMap/Internal.hs
@@ -77,6 +77,7 @@
     , foldr'
     , foldlWithKey'
     , foldrWithKey'
+    , foldMapWithKey'
 
     -- * Monoidal operations
 
@@ -1083,12 +1084,6 @@
 -- Each application of the operator is evaluated before using the result in the
 -- next application. This function is strict in the starting value.
 --
--- Satisfies the following property:
---
--- @
--- 'foldl'' f r m '==' 'Map'.'Map.foldl'' f r ('toMap' m)
--- @
---
 -- @since 0.0.1.7
 --
 foldl' :: (r -> v -> r) -> r -> MonoidMap k v -> r
@@ -1105,12 +1100,6 @@
 -- Each application of the operator is evaluated before using the result in the
 -- next application. This function is strict in the starting value.
 --
--- Satisfies the following property:
---
--- @
--- 'foldr'' f r m '==' 'Map'.'Map.foldr'' f r ('toMap' m)
--- @
---
 -- @since 0.0.1.7
 --
 foldr' :: (v -> r -> r) -> r -> MonoidMap k v -> r
@@ -1127,12 +1116,6 @@
 -- Each application of the operator is evaluated before using the result in the
 -- next application. This function is strict in the starting value.
 --
--- Satisfies the following property:
---
--- @
--- 'foldlWithKey'' f r m '==' 'Map'.'Map.foldlWithKey'' f r ('toMap' m)
--- @
---
 -- @since 0.0.1.7
 --
 foldlWithKey' :: (r -> k -> v -> r) -> r -> MonoidMap k v -> r
@@ -1149,12 +1132,6 @@
 -- Each application of the operator is evaluated before using the result in the
 -- next application. This function is strict in the starting value.
 --
--- Satisfies the following property:
---
--- @
--- 'foldrWithKey'' f r m '==' 'Map'.'Map.foldrWithKey'' f r ('toMap' m)
--- @
---
 -- @since 0.0.1.7
 --
 foldrWithKey' :: (k -> v -> r -> r) -> r -> MonoidMap k v -> r
@@ -1165,6 +1142,17 @@
     )
     Map.foldrWithKey'
 {-# INLINE foldrWithKey' #-}
+
+-- | \(O(n)\). A strict version of 'foldMapWithKey'.
+--
+-- Each application of `mappend` is evaluated before using the result in the
+-- next application.
+--
+-- @since 0.0.1.8
+--
+foldMapWithKey' :: Monoid r => (k -> v -> r) -> MonoidMap k v -> r
+foldMapWithKey' f = foldlWithKey' (\r k v -> r <> f k v) mempty
+{-# INLINE foldMapWithKey' #-}
 
 --------------------------------------------------------------------------------
 -- Comparison
diff --git a/src/public/Data/MonoidMap.hs b/src/public/Data/MonoidMap.hs
--- a/src/public/Data/MonoidMap.hs
+++ b/src/public/Data/MonoidMap.hs
@@ -76,6 +76,7 @@
     , foldr'
     , foldlWithKey'
     , foldrWithKey'
+    , foldMapWithKey'
 
     -- * Monoidal operations
 
diff --git a/src/test/Data/MonoidMap/FoldSpec.hs b/src/test/Data/MonoidMap/FoldSpec.hs
--- a/src/test/Data/MonoidMap/FoldSpec.hs
+++ b/src/test/Data/MonoidMap/FoldSpec.hs
@@ -36,92 +36,95 @@
 
     describe "Lazy" $ do
 
-        it "prop_toMap_foldl" $
-            prop_toMap_foldl
+        it "prop_equivalence_foldl" $
+            prop_equivalence_foldl
                 @k @v & property
-        it "prop_toMap_foldr" $
-            prop_toMap_foldr
+        it "prop_equivalence_foldr" $
+            prop_equivalence_foldr
                 @k @v & property
-        it "prop_toMap_foldlWithKey" $
-            prop_toMap_foldlWithKey
+        it "prop_equivalence_foldlWithKey" $
+            prop_equivalence_foldlWithKey
                 @k @v & property
-        it "prop_toMap_foldrWithKey" $
-            prop_toMap_foldrWithKey
+        it "prop_equivalence_foldrWithKey" $
+            prop_equivalence_foldrWithKey
                 @k @v & property
-        it "prop_toMap_foldMapWithKey" $
-            prop_toMap_foldMapWithKey
+        it "prop_equivalence_foldMapWithKey" $
+            prop_equivalence_foldMapWithKey
                 @k @v & property
 
     describe "Strict" $ do
 
-        it "prop_toMap_foldl'" $
-            prop_toMap_foldl'
+        it "prop_equivalence_foldl'" $
+            prop_equivalence_foldl'
                 @k @v & property
-        it "prop_toMap_foldr'" $
-            prop_toMap_foldr'
+        it "prop_equivalence_foldr'" $
+            prop_equivalence_foldr'
                 @k @v & property
-        it "prop_toMap_foldlWithKey'" $
-            prop_toMap_foldlWithKey'
+        it "prop_equivalence_foldlWithKey'" $
+            prop_equivalence_foldlWithKey'
                 @k @v & property
-        it "prop_toMap_foldrWithKey'" $
-            prop_toMap_foldrWithKey'
+        it "prop_equivalence_foldrWithKey'" $
+            prop_equivalence_foldrWithKey'
                 @k @v & property
+        it "prop_equivalence_foldMapWithKey'" $
+            prop_equivalence_foldMapWithKey'
+                @k @v & property
 
 --------------------------------------------------------------------------------
 -- Lazy folding
 --------------------------------------------------------------------------------
 
-prop_toMap_foldl
+prop_equivalence_foldl
     :: Test k v
     => r ~ v
     => Fun (r, v) r
     -> r
     -> MonoidMap k v
     -> Property
-prop_toMap_foldl (applyFun2 -> f) r m =
+prop_equivalence_foldl (applyFun2 -> f) r m =
     MonoidMap.foldl f r m
       === Map.foldl f r (MonoidMap.toMap m)
 
-prop_toMap_foldr
+prop_equivalence_foldr
     :: Test k v
     => r ~ v
     => Fun (v, r) r
     -> r
     -> MonoidMap k v
     -> Property
-prop_toMap_foldr (applyFun2 -> f) r m =
+prop_equivalence_foldr (applyFun2 -> f) r m =
     MonoidMap.foldr f r m
       === Map.foldr f r (MonoidMap.toMap m)
 
-prop_toMap_foldlWithKey
+prop_equivalence_foldlWithKey
     :: Test k v
     => r ~ v
     => Fun (r, k, v) r
     -> r
     -> MonoidMap k v
     -> Property
-prop_toMap_foldlWithKey (applyFun3 -> f) r m =
+prop_equivalence_foldlWithKey (applyFun3 -> f) r m =
     MonoidMap.foldlWithKey f r m
       === Map.foldlWithKey f r (MonoidMap.toMap m)
 
-prop_toMap_foldrWithKey
+prop_equivalence_foldrWithKey
     :: Test k v
     => r ~ v
     => Fun (k, v, r) r
     -> r
     -> MonoidMap k v
     -> Property
-prop_toMap_foldrWithKey (applyFun3 -> f) r m =
+prop_equivalence_foldrWithKey (applyFun3 -> f) r m =
     MonoidMap.foldrWithKey f r m
       === Map.foldrWithKey f r (MonoidMap.toMap m)
 
-prop_toMap_foldMapWithKey
+prop_equivalence_foldMapWithKey
     :: Test k v
     => r ~ v
     => Fun (k, v) r
     -> MonoidMap k v
     -> Property
-prop_toMap_foldMapWithKey (applyFun2 -> f) m =
+prop_equivalence_foldMapWithKey (applyFun2 -> f) m =
     MonoidMap.foldMapWithKey f m
       === Map.foldMapWithKey f (MonoidMap.toMap m)
 
@@ -129,46 +132,56 @@
 -- Strict folding
 --------------------------------------------------------------------------------
 
-prop_toMap_foldl'
+prop_equivalence_foldl'
     :: Test k v
     => r ~ v
     => Fun (r, v) r
     -> r
     -> MonoidMap k v
     -> Property
-prop_toMap_foldl' (applyFun2 -> f) r m =
-    MonoidMap.foldl' f r m
-      === Map.foldl' f r (MonoidMap.toMap m)
+prop_equivalence_foldl' (applyFun2 -> f) r m =
+    MonoidMap.foldl' f r m ===
+    MonoidMap.foldl  f r m
 
-prop_toMap_foldr'
+prop_equivalence_foldr'
     :: Test k v
     => r ~ v
     => Fun (v, r) r
     -> r
     -> MonoidMap k v
     -> Property
-prop_toMap_foldr' (applyFun2 -> f) r m =
-    MonoidMap.foldr' f r m
-      === Map.foldr' f r (MonoidMap.toMap m)
+prop_equivalence_foldr' (applyFun2 -> f) r m =
+    MonoidMap.foldr' f r m ===
+    MonoidMap.foldr  f r m
 
-prop_toMap_foldlWithKey'
+prop_equivalence_foldlWithKey'
     :: Test k v
     => r ~ v
     => Fun (r, k, v) r
     -> r
     -> MonoidMap k v
     -> Property
-prop_toMap_foldlWithKey' (applyFun3 -> f) r m =
-    MonoidMap.foldlWithKey' f r m
-      === Map.foldlWithKey' f r (MonoidMap.toMap m)
+prop_equivalence_foldlWithKey' (applyFun3 -> f) r m =
+    MonoidMap.foldlWithKey' f r m ===
+    MonoidMap.foldlWithKey  f r m
 
-prop_toMap_foldrWithKey'
+prop_equivalence_foldrWithKey'
     :: Test k v
     => r ~ v
     => Fun (k, v, r) r
     -> r
     -> MonoidMap k v
     -> Property
-prop_toMap_foldrWithKey' (applyFun3 -> f) r m =
-    MonoidMap.foldrWithKey' f r m
-      === Map.foldrWithKey' f r (MonoidMap.toMap m)
+prop_equivalence_foldrWithKey' (applyFun3 -> f) r m =
+    MonoidMap.foldrWithKey' f r m ===
+    MonoidMap.foldrWithKey  f r m
+
+prop_equivalence_foldMapWithKey'
+    :: Test k v
+    => r ~ v
+    => Fun (k, v) r
+    -> MonoidMap k v
+    -> Property
+prop_equivalence_foldMapWithKey' (applyFun2 -> f) m =
+    MonoidMap.foldMapWithKey' f m ===
+    MonoidMap.foldMapWithKey  f m