diff --git a/docs/manpages/nfdc-cs.rst b/docs/manpages/nfdc-cs.rst
index 99b46d8..831dd7d 100644
--- a/docs/manpages/nfdc-cs.rst
+++ b/docs/manpages/nfdc-cs.rst
@@ -5,6 +5,7 @@
 --------
 | nfdc cs [info]
 | nfdc cs config [capacity <CAPACITY>] [admit on|off] [serve on|off]
+| nfdc cs erase <PREFIX> [count <COUNT>]
 
 DESCRIPTION
 -----------
@@ -12,6 +13,8 @@
 
 The **nfdc cs config** command updates CS configuration.
 
+The **nfdc cs erase** command erases cached Data under a name prefix.
+
 OPTIONS
 -------
 <CAPACITY>
@@ -25,6 +28,13 @@
     Whether the CS can satisfy incoming Interests using cached Data.
     Turning this off causes all CS lookups to miss.
 
+<PREFIX>
+    Name prefix of cached Data packets.
+
+<COUNT>
+    Maximum number of cached Data packets to erase.
+    The default is "no limit".
+
 SEE ALSO
 --------
 nfd(1), nfdc(1)
