diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,3 +15,15 @@
 ## 0.2.0.1
 
 * Update CHANGELOG, README
+
+## 0.3.0.0
+
+* Add markdown support
+
+* Update typeclass names in `Servant.Docs.Simple.Parse`:
+
+  `HasParsable` -> `HasParsableApi`
+  
+  `HasDocumentApi` -> `HasParsableEndpoint`
+  
+  `parse` -> `parseApi`
diff --git a/servant-docs-simple.cabal b/servant-docs-simple.cabal
--- a/servant-docs-simple.cabal
+++ b/servant-docs-simple.cabal
@@ -1,6 +1,6 @@
 cabal-version:       2.4
 name:                servant-docs-simple
-version:             0.2.0.1
+version:             0.3.0.0
 synopsis:            Generate endpoints overview for Servant API
 
 description:
@@ -63,6 +63,7 @@
                        DerivingStrategies
                        FlexibleInstances
                        FunctionalDependencies
+                       LambdaCase
                        OverloadedStrings
                        PolyKinds
                        ScopedTypeVariables
diff --git a/src/Servant/Docs/Simple.hs b/src/Servant/Docs/Simple.hs
--- a/src/Servant/Docs/Simple.hs
+++ b/src/Servant/Docs/Simple.hs
@@ -70,8 +70,10 @@
 module Servant.Docs.Simple ( document
                            , documentWith
                            , stdoutJson
+                           , stdoutMarkdown
                            , stdoutPlainText
                            , writeDocsJson
+                           , writeDocsMarkdown
                            , writeDocsPlainText
                            ) where
 
@@ -79,30 +81,39 @@
 import qualified Data.ByteString.Lazy as B (writeFile)
 import qualified Data.ByteString.Lazy.Char8 as BC (putStrLn)
 import qualified Data.Text.IO as T (putStrLn, writeFile)
-import Servant.Docs.Simple.Parse (HasParsable (..))
-import Servant.Docs.Simple.Render (Json (..), PlainText (..), Renderable (..))
 
+import Servant.Docs.Simple.Parse (HasParsableApi (..))
+import Servant.Docs.Simple.Render (Json (..), Markdown (..), PlainText (..), Renderable (..))
 
+
 -- | Write documentation as PlainText to file
-writeDocsPlainText :: forall api. HasParsable api => FilePath -> IO ()
+writeDocsPlainText :: forall api. HasParsableApi api => FilePath -> IO ()
 writeDocsPlainText fp = T.writeFile fp . getPlainText $ document @api
 
+-- | Write documentation as Markdown to file
+writeDocsMarkdown :: forall api. HasParsableApi api => FilePath -> IO ()
+writeDocsMarkdown fp = T.writeFile fp . getMarkdown $ documentWith @api @Markdown
+
 -- | Write documentation as JSON to file
-writeDocsJson :: forall api. HasParsable api => FilePath -> IO ()
+writeDocsJson :: forall api. HasParsableApi api => FilePath -> IO ()
 writeDocsJson fp = B.writeFile fp . encodePretty . getJson $ documentWith @api @Json
 
 -- | Write documentation as PlainText to stdout
-stdoutPlainText :: forall api. HasParsable api => IO ()
+stdoutPlainText :: forall api. HasParsableApi api => IO ()
 stdoutPlainText = T.putStrLn . getPlainText $ document @api
 
+-- | Write documentation as Markdown to stdout
+stdoutMarkdown :: forall api. HasParsableApi api => IO ()
+stdoutMarkdown = T.putStrLn . getMarkdown $ documentWith @api @Markdown
+
 -- | Write documentation as JSON to stdout
-stdoutJson :: forall api. HasParsable api => IO ()
+stdoutJson :: forall api. HasParsableApi api => IO ()
 stdoutJson = BC.putStrLn . encodePretty . getJson $ documentWith @api @Json
 
 -- | Convert API type into PlainText format
-document :: forall api. HasParsable api => PlainText
+document :: forall api. HasParsableApi api => PlainText
 document = documentWith @api @PlainText
 
 -- | Convert API type into specified formats
-documentWith :: forall api a. (HasParsable api, Renderable a) => a
-documentWith = render @a (parse @api)
+documentWith :: forall api a. (HasParsableApi api, Renderable a) => a
+documentWith = render @a (parseApi @api)
diff --git a/src/Servant/Docs/Simple/Parse.hs b/src/Servant/Docs/Simple/Parse.hs
--- a/src/Servant/Docs/Simple/Parse.hs
+++ b/src/Servant/Docs/Simple/Parse.hs
@@ -46,8 +46,8 @@
 {-# LANGUAGE UndecidableInstances #-}
 
 module Servant.Docs.Simple.Parse
-       ( HasDocumentApi (..)
-       , HasParsable (..)
+       ( HasParsableEndpoint (..)
+       , HasParsableApi (..)
        , symbolVal'
        , toDetails
        , typeText
@@ -69,16 +69,16 @@
 import Servant.Docs.Simple.Render (ApiDocs (..), Details (..), Parameter, Route)
 
 -- | Flattens API into type level list of Endpoints
-class HasParsable api where
-    parse :: ApiDocs
+class HasParsableApi api where
+    parseApi :: ApiDocs
 
 -- | If the flattened API can be collated into documentation, it is parsable
-instance HasCollatable (S.Endpoints a) => HasParsable a where
-    parse = collate @(S.Endpoints a)
+instance HasCollatable (S.Endpoints a) => HasParsableApi a where
+    parseApi = collate @(S.Endpoints a)
 
 -- | Empty APIs should have no documentation
-instance {-# OVERLAPPING #-} HasParsable EmptyAPI where
-    parse = collate @'[]
+instance {-# OVERLAPPING #-} HasParsableApi EmptyAPI where
+    parseApi = collate @'[]
 
 -- | Folds api endpoints into documentation
 class HasCollatable api where
@@ -86,8 +86,8 @@
     collate :: ApiDocs
 
 -- | Collapse a type-level list of API endpoints into documentation
-instance (HasDocumentApi api, HasCollatable b) => HasCollatable (api ': b) where
-    collate = ApiDocs $ (Details <$> documentEndpoint @api) |< previous
+instance (HasParsableEndpoint e, HasCollatable b) => HasCollatable (e ': b) where
+    collate = ApiDocs $ (Details <$> documentEndpoint @e) |< previous
       where ApiDocs previous = collate @b
 
 -- | Terminal step when there are no more endpoints left to recurse over
@@ -95,64 +95,64 @@
     collate = ApiDocs empty
 
 -- | Folds an api endpoint into documentation
-documentEndpoint :: forall a. HasDocumentApi a => (Route, OMap Parameter Details)
-documentEndpoint = document @a "" []
+documentEndpoint :: forall a. HasParsableEndpoint a => (Route, OMap Parameter Details)
+documentEndpoint = parseEndpoint @a "" []
 
 -- | Folds an api endpoint into documentation
-class HasDocumentApi api where
+class HasParsableEndpoint e where
 
     -- | We use this to destructure the API type and convert it into documentation
-    document :: Route -- ^ Route documentation
-             -> [(Parameter, Details)] -- ^ Everything else documentation
-             -> (Route, OMap Parameter Details) -- ^ Generated documentation for the route
+    parseEndpoint :: Route -- ^ Route documentation
+                  -> [(Parameter, Details)] -- ^ Everything else documentation
+                  -> (Route, OMap Parameter Details) -- ^ Generated documentation for the route
 
 -- | Static route documentation
-instance (HasDocumentApi b, KnownSymbol route) => HasDocumentApi ((route :: Symbol) :> b) where
-    document r = document @b formatted
-        where formatted = fold [r, "/", fragment]
-              fragment = symbolVal' @route
+instance (HasParsableEndpoint b, KnownSymbol route) => HasParsableEndpoint ((route :: Symbol) :> b) where
+    parseEndpoint r = parseEndpoint @b formatted
+      where formatted = fold [r, "/", fragment]
+            fragment = symbolVal' @route
 
 -- | Capture documentation
-instance (HasDocumentApi b, KnownSymbol dRoute, Typeable t) => HasDocumentApi (Capture' m (dRoute :: Symbol) t :> b) where
-    document r = document @b formatted
-        where formatted = fold [r, "/", "{", var, "::", format, "}"]
-              var = symbolVal' @dRoute
-              format = typeText @t
+instance (HasParsableEndpoint b, KnownSymbol dRoute, Typeable t) => HasParsableEndpoint (Capture' m (dRoute :: Symbol) t :> b) where
+    parseEndpoint r = parseEndpoint @b formatted
+      where formatted = fold [r, "/", "{", var, "::", format, "}"]
+            var = symbolVal' @dRoute
+            format = typeText @t
 
 -- | CaptureAll documentation
-instance (HasDocumentApi b, KnownSymbol dRoute, Typeable t) => HasDocumentApi (CaptureAll (dRoute :: Symbol) t :> b) where
-    document r = document @b formatted
-        where formatted = fold [r, "/", "{", var, "::", format, "}"]
-              var = symbolVal' @dRoute
-              format = typeText @t
+instance (HasParsableEndpoint b, KnownSymbol dRoute, Typeable t) => HasParsableEndpoint (CaptureAll (dRoute :: Symbol) t :> b) where
+    parseEndpoint r = parseEndpoint @b formatted
+      where formatted = fold [r, "/", "{", var, "::", format, "}"]
+            var = symbolVal' @dRoute
+            format = typeText @t
 
 -- | Request HttpVersion documentation
-instance HasDocumentApi b => HasDocumentApi (HttpVersion :> b) where
-    document r a = document @b r $ a <> [("Captures Http Version", Detail "True")]
+instance HasParsableEndpoint b => HasParsableEndpoint (HttpVersion :> b) where
+    parseEndpoint r a = parseEndpoint @b r $ a <> [("Captures Http Version", Detail "True")]
 
 -- | IsSecure documentation
-instance HasDocumentApi b => HasDocumentApi (IsSecure :> b) where
-    document r a = document @b r $ a <> [("SSL Only", Detail "True")]
+instance HasParsableEndpoint b => HasParsableEndpoint (IsSecure :> b) where
+    parseEndpoint r a = parseEndpoint @b r $ a <> [("SSL Only", Detail "True")]
 
 -- | Request Remote host documentation
-instance HasDocumentApi b => HasDocumentApi (RemoteHost :> b) where
-    document r a = document @b r $ a <> [("Captures RemoteHost/IP", Detail "True")]
+instance HasParsableEndpoint b => HasParsableEndpoint (RemoteHost :> b) where
+    parseEndpoint r a = parseEndpoint @b r $ a <> [("Captures RemoteHost/IP", Detail "True")]
 
 -- | Description documentation
-instance (HasDocumentApi b, KnownSymbol desc) => HasDocumentApi (Description (desc :: Symbol) :> b) where
-    document r a = document @b r $ a <> [("Description", Detail $ symbolVal' @desc)]
+instance (HasParsableEndpoint b, KnownSymbol desc) => HasParsableEndpoint (Description (desc :: Symbol) :> b) where
+    parseEndpoint r a = parseEndpoint @b r $ a <> [("Description", Detail $ symbolVal' @desc)]
 
 -- | Summary documentation
-instance (HasDocumentApi b, KnownSymbol s) => HasDocumentApi (Summary (s :: Symbol) :> b) where
-    document r a = document @b r $ a <> [("Summary", Detail $ symbolVal' @s)]
+instance (HasParsableEndpoint b, KnownSymbol s) => HasParsableEndpoint (Summary (s :: Symbol) :> b) where
+    parseEndpoint r a = parseEndpoint @b r $ a <> [("Summary", Detail $ symbolVal' @s)]
 
 -- | Vault documentation
-instance HasDocumentApi b => HasDocumentApi (Vault :> b) where
-    document r a = document @b r $ a <> [("Vault", Detail "True")]
+instance HasParsableEndpoint b => HasParsableEndpoint (Vault :> b) where
+    parseEndpoint r a = parseEndpoint @b r $ a <> [("Vault", Detail "True")]
 
 -- | Basic authentication documentation
-instance (HasDocumentApi b, KnownSymbol realm, Typeable a) => HasDocumentApi (BasicAuth (realm :: Symbol) a :> b) where
-    document r a = document @b r $ a <> [( "Basic Authentication"
+instance (HasParsableEndpoint b, KnownSymbol realm, Typeable a) => HasParsableEndpoint (BasicAuth (realm :: Symbol) a :> b) where
+    parseEndpoint r a = parseEndpoint @b r $ a <> [( "Basic Authentication"
                                         , toDetails [ ("Realm", Detail realm)
                                                     , ("UserData", Detail userData)
                                                     ]
@@ -162,51 +162,51 @@
               userData = typeText @a
 
 -- | Authentication documentation
-instance (HasDocumentApi b, KnownSymbol token) => HasDocumentApi (AuthProtect (token :: Symbol) :> b) where
-    document r a = document @b r $ a <> [("Authentication", Detail authDoc)]
+instance (HasParsableEndpoint b, KnownSymbol token) => HasParsableEndpoint (AuthProtect (token :: Symbol) :> b) where
+    parseEndpoint r a = parseEndpoint @b r $ a <> [("Authentication", Detail authDoc)]
         where authDoc = symbolVal' @token
 
 -- | Request header documentation
-instance (HasDocumentApi b, KnownSymbol ct, Typeable typ) => HasDocumentApi (Header' m (ct :: Symbol) typ :> b) where
-    document r a = document @b r $ a <> [( "RequestHeaders"
+instance (HasParsableEndpoint b, KnownSymbol ct, Typeable typ) => HasParsableEndpoint (Header' m (ct :: Symbol) typ :> b) where
+    parseEndpoint r a = parseEndpoint @b r $ a <> [( "RequestHeaders"
                                         , toDetails [ ("Name", Detail $ symbolVal' @ct)
                                                     , ("ContentType", Detail $ typeText @typ)
                                                     ]
                                         )]
 
 -- | Query flag documentation
-instance (HasDocumentApi b, KnownSymbol param) => HasDocumentApi (QueryFlag (param :: Symbol) :> b) where
-    document r a = document @b r $ a <> [( "QueryFlag"
+instance (HasParsableEndpoint b, KnownSymbol param) => HasParsableEndpoint (QueryFlag (param :: Symbol) :> b) where
+    parseEndpoint r a = parseEndpoint @b r $ a <> [( "QueryFlag"
                                         , toDetails [ ("Param", Detail $ symbolVal' @param) ]
                                         )]
 
 -- | Query param documentation
-instance (HasDocumentApi b, KnownSymbol param, Typeable typ) => HasDocumentApi (QueryParam' m (param :: Symbol) typ :> b) where
-    document r a = document @b r $ a <> [( "QueryParam"
+instance (HasParsableEndpoint b, KnownSymbol param, Typeable typ) => HasParsableEndpoint (QueryParam' m (param :: Symbol) typ :> b) where
+    parseEndpoint r a = parseEndpoint @b r $ a <> [( "QueryParam"
                                         , toDetails [ ("Param", Detail $ symbolVal' @param)
                                                     , ("ContentType", Detail $ typeText @typ)
                                                     ]
                                         )]
 
 -- | Query params documentation
-instance (HasDocumentApi b, KnownSymbol param, Typeable typ) => HasDocumentApi (QueryParams (param :: Symbol) typ :> b) where
-    document r a = document @b r $ a <> [(  "QueryParams"
+instance (HasParsableEndpoint b, KnownSymbol param, Typeable typ) => HasParsableEndpoint (QueryParams (param :: Symbol) typ :> b) where
+    parseEndpoint r a = parseEndpoint @b r $ a <> [(  "QueryParams"
                                         , toDetails [ ("Param", Detail $ symbolVal' @param)
                                                     , ("ContentType", Detail $ typeText @typ)
                                                     ]
                                         )]
 
 -- | Request body documentation
-instance (HasDocumentApi b, Typeable ct, Typeable typ) => HasDocumentApi (ReqBody' m ct typ :> b) where
-    document r a = document @b r $ a <> [( "RequestBody"
+instance (HasParsableEndpoint b, Typeable ct, Typeable typ) => HasParsableEndpoint (ReqBody' m ct typ :> b) where
+    parseEndpoint r a = parseEndpoint @b r $ a <> [( "RequestBody"
                                         , toDetails [ ("Format", Detail $ typeText @ct)
                                                     , ("ContentType", Detail $ typeText @typ)
                                                     ]
                                         )]
 
 -- | Stream body documentation
-instance (HasDocumentApi b, Typeable ct, Typeable typ) => HasDocumentApi (StreamBody' m ct typ :> b) where
-    document r a = document @b r $ a <> [( "StreamBody"
+instance (HasParsableEndpoint b, Typeable ct, Typeable typ) => HasParsableEndpoint (StreamBody' m ct typ :> b) where
+    parseEndpoint r a = parseEndpoint @b r $ a <> [( "StreamBody"
                                         , toDetails [ ("Format", Detail $ typeText @ct)
                                                     , ("ContentType", Detail $ typeText @typ)
                                                     ]
@@ -215,8 +215,8 @@
 -- | Response documentation
 --   Terminates here as responses are last parts of api endpoints
 --   Note that request type information (GET, POST etc...) is contained here
-instance (Typeable m, Typeable ct, Typeable typ) => HasDocumentApi (Verb m s ct typ) where
-    document r a = ( r
+instance (Typeable m, Typeable ct, Typeable typ) => HasParsableEndpoint (Verb m s ct typ) where
+    parseEndpoint r a = ( r
                    , fromList $ a <> [requestType, response]
                    )
         where requestType = ("RequestType", Detail $ typeText @m)
diff --git a/src/Servant/Docs/Simple/Render.hs b/src/Servant/Docs/Simple/Render.hs
--- a/src/Servant/Docs/Simple/Render.hs
+++ b/src/Servant/Docs/Simple/Render.hs
@@ -72,6 +72,7 @@
        , Parameter
        , Route
        , Json (..)
+       , Markdown (..)
        , Pretty (..)
        , PlainText (..)
        ) where
@@ -81,7 +82,9 @@
 import Data.List (intersperse)
 import Data.Map.Ordered (OMap, assocs)
 import Data.Text (Text, pack)
-import Data.Text.Prettyprint.Doc (Doc, cat, line, nest, pretty, vcat, vsep)
+import Data.Text.Prettyprint.Doc (Doc, annotate, defaultLayoutOptions, indent, layoutPretty, line,
+                                  pretty, vcat, vsep)
+import Data.Text.Prettyprint.Doc.Render.Util.StackMachine (renderSimplyDecorated)
 
 -- | Intermediate documentation structure, a hashmap of endpoints
 --
@@ -169,27 +172,64 @@
     toJSON (Details ls) = toJSON . fromList . assocs $ ls
 
 -- | Conversion to prettyprint
-newtype Pretty ann = Pretty { getPretty :: Doc ann }
+newtype Pretty = Pretty { getPretty :: Doc Ann }
 
+-- | Annotates our route and parameter keys
+data Ann = AnnRoute | AnnParam | AnnDetail
+
 -- | Conversion to prettyprint
-instance Renderable (Pretty ann) where
+instance Renderable Pretty where
     render = Pretty . prettyPrint
 
 -- | Helper function to prettyprint the ApiDocs
-prettyPrint :: ApiDocs -> Doc ann
-prettyPrint (ApiDocs endpoints) = vcat . intersperse line
-                                $ uncurry (toDoc 0) <$> assocs endpoints
+prettyPrint :: ApiDocs -> Doc Ann
+prettyPrint (ApiDocs endpoints) = vsep
+                                $ intersperse line
+                                $ documentRoute
+                              <$> assocs endpoints
 
--- | Helper function
-toDoc :: Int -> Text -> Details -> Doc ann
-toDoc i t d = case d of
-    Detail a   -> cat [pretty t, ": ", pretty a]
-    Details as -> nest i . vsep $ pretty t <> ":"
-                                : (uncurry (toDoc (i + 4)) <$> assocs as)
+-- | Documents an API route
+documentRoute :: (Route, Details) -- ^ Route-Details pair
+               -> Doc Ann -- ^ documentation for Route-Details pair
+documentRoute (r, d) = routeDoc <> ":" <> detailsDoc
+  where routeDoc = annotate AnnRoute $ pretty r
+        detailsDoc = documentDetails 0 d
 
+-- | Documents Details of an API route
+documentDetails :: Int -- ^ Indentation
+                -> Details -- ^ Details
+                -> Doc Ann -- ^ documentation for Details
+documentDetails i d = case d of
+    Detail d'  -> " " <> annotate AnnDetail (pretty d')
+    Details ds -> (line <>)
+                $ indent i
+                $ vcat
+                $ documentParameters <$> ds'
+      where ds' = assocs ds
+            documentParameters (param, details) = annotate AnnParam (pretty param)
+                                               <> ":"
+                                               <> documentDetails (i + 4) details
+
 -- | Conversion to plaintext
 newtype PlainText = PlainText { getPlainText :: Text } deriving stock (Eq, Show)
 
 -- | Conversion to plaintext
 instance Renderable PlainText where
     render = PlainText . pack . show . getPretty . render
+
+-- | Conversion to markdown
+newtype Markdown = Markdown { getMarkdown :: Text } deriving stock (Eq, Show)
+
+instance Renderable Markdown where
+    render docs = Markdown m
+      where m = renderSimplyDecorated id annOpen annClose docStream
+            annOpen = \case
+              AnnRoute -> "### "
+              AnnParam -> "- **"
+              AnnDetail -> "`"
+            annClose = \case
+              AnnRoute -> ""
+              AnnParam -> "**"
+              AnnDetail -> "`"
+            docStream = layoutPretty defaultLayoutOptions docs'
+            docs' = getPretty $ render docs
diff --git a/test/Test/Servant/Docs/Simple/Parse.hs b/test/Test/Servant/Docs/Simple/Parse.hs
--- a/test/Test/Servant/Docs/Simple/Parse.hs
+++ b/test/Test/Servant/Docs/Simple/Parse.hs
@@ -10,15 +10,15 @@
 import Test.Servant.Docs.Simple.Samples (ApiComplete, ApiMultiple, apiCompleteParsed,
                                          apiMultipleParsed)
 
-import Servant.Docs.Simple.Parse (parse)
+import Servant.Docs.Simple.Parse (parseApi)
 import Servant.Docs.Simple.Render (ApiDocs (..))
 
 
 parseSpec :: Spec
 parseSpec = describe "Parses API to Document Tree" $ do
     it "parses an EmptyAPI Details" $
-        parse @EmptyAPI `shouldBe` ApiDocs empty
+        parseApi @EmptyAPI `shouldBe` ApiDocs empty
     it "parses all Servant API Combinators" $
-        parse @ApiComplete `shouldBe` apiCompleteParsed
+        parseApi @ApiComplete `shouldBe` apiCompleteParsed
     it "parses an API with multiple endpoints" $
-        parse @ApiMultiple `shouldBe` apiMultipleParsed
+        parseApi @ApiMultiple `shouldBe` apiMultipleParsed