diff --git a/runtime/doc/channel.txt b/runtime/doc/channel.txt
index 5d7e907..35a5548 100644
--- a/runtime/doc/channel.txt
+++ b/runtime/doc/channel.txt
@@ -1485,7 +1485,7 @@
     let resp = ch_sendexpr(ch, req, #{callback: 'HoverFunc'})
 
 To cancel an outstanding asynchronous LSP request sent to the server using the
-|ch_sendexpr()| function, send a cancelation message to the server using the
+|ch_sendexpr()| function, send a cancellation message to the server using the
 |ch_sendexpr()| function with the ID returned by the |ch_sendexpr()| function
 for the request.  Example: >
 
@@ -1533,7 +1533,7 @@
 	"params": <list|dict>
     }
 
-A LSP reponse message has the following format (expressed as a Vim Dict).  The
+A LSP response message has the following format (expressed as a Vim Dict).  The
 "result" and "error" fields are optional: >
 
     {
@@ -1565,7 +1565,7 @@
 	"params": <list|dict>
     }
 
-A LSP reponse message has the following format (expressed as a Vim Dict).  The
+A LSP response message has the following format (expressed as a Vim Dict).  The
 "result" and "error" fields are optional: >
 
     {
