diff --git a/.idea/runConfigurations/Backend____Jetty.xml b/.idea/runConfigurations/Backend____Jetty.xml
index 17fe544..4abe07e 100644
--- a/.idea/runConfigurations/Backend____Jetty.xml
+++ b/.idea/runConfigurations/Backend____Jetty.xml
@@ -2,7 +2,7 @@
   <configuration default="false" name="Backend :: Jetty" type="Application" factoryName="Application" singleton="true">
     <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
     <extension name="org.jetbrains.fluid.java.FluidRunConfigurationExtension" fluid.enabledBundledTracers="false" fluid.enabledBundledTracers.list="" />
-    <option name="MAIN_CLASS_NAME" value="org.jetbrains.ktor.jetty.DevelopmentHost" />
+    <option name="MAIN_CLASS_NAME" value="io.ktor.server.jetty.DevelopmentEngine" />
     <option name="VM_PARAMETERS" value="" />
     <option name="PROGRAM_PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$" />
@@ -11,7 +11,7 @@
     <option name="ENABLE_SWING_INSPECTOR" value="false" />
     <option name="ENV_VARIABLES" />
     <option name="PASS_PARENT_ENVS" value="true" />
-    <module name="backend" />
+    <module name="backend_main" />
     <envs />
     <RunnerSettings RunnerId="JProfiler" />
     <method />
diff --git a/backend/build.gradle b/backend/build.gradle
index 6097f03..fb2e0e7 100644
--- a/backend/build.gradle
+++ b/backend/build.gradle
@@ -8,18 +8,18 @@ dependencies {
     compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
     compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
 
-    compile "org.jetbrains.ktor:ktor-locations:$ktor_version"
-    compile "org.jetbrains.ktor:ktor-html-builder:$ktor_version"
+    compile "io.ktor:ktor-locations:$ktor_version"
+    compile "io.ktor:ktor-html-builder:$ktor_version"
     compile "org.ehcache:ehcache:3.0.0.m4"
 
     compile "org.jetbrains.squash:squash-h2:$squash_version"
 
     testCompile("org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version")
-    testCompile "org.jetbrains.ktor:ktor-test-host:$ktor_version"
+    testCompile "io.ktor:ktor-server-test-host:$ktor_version"
     testCompile "org.jsoup:jsoup:1.9.1"
 
-    compile "org.jetbrains.ktor:ktor-jetty:$ktor_version"
-    compile group: 'com.google.code.gson', name: 'gson', version: '2.8.0'
+    compile "io.ktor:ktor-server-jetty:$ktor_version"
+    compile group: "io.ktor", name: "ktor-gson", version: "0.9.0"
 }
 
 sourceSets {
@@ -41,4 +41,4 @@ kotlin {
     }
 }
 
-mainClassName = 'org.jetbrains.ktor.jetty.DevelopmentHost'
+mainClassName = "io.ktor.server.netty.DevelopmentEngine"
diff --git a/backend/src/org/jetbrains/demo/thinkter/Application.kt b/backend/src/org/jetbrains/demo/thinkter/Application.kt
index e5fb2b4..64d5e69 100644
--- a/backend/src/org/jetbrains/demo/thinkter/Application.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/Application.kt
@@ -1,17 +1,14 @@
 package org.jetbrains.demo.thinkter
 
-import com.google.gson.*
 import org.jetbrains.demo.thinkter.dao.*
-import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.content.*
-import org.jetbrains.ktor.features.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.logging.*
-import org.jetbrains.ktor.routing.*
-import org.jetbrains.ktor.sessions.*
-import org.jetbrains.ktor.transform.*
+import io.ktor.application.*
+import io.ktor.features.*
+import io.ktor.gson.GsonConverter
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.response.respond
+import io.ktor.routing.*
+import io.ktor.sessions.*
 
 data class Session(val userId: String)
 
@@ -28,17 +25,17 @@ fun Application.main() {
         exception<NotImplementedError> { call.respond(HttpStatusCode.NotImplemented) }
     }
 
-    withSessions<Session> {
-        withCookieByValue {
-            settings = SessionCookiesSettings(transformers = listOf(SessionCookieTransformerMessageAuthentication(hashKey)))
+    install(Sessions){
+        cookie<Session>("SESSION"){
+            transform(SessionTransportTransformerMessageAuthentication(hashKey))
         }
     }
 
-    transform.register<RpcData> {
-        TextContent(Gson().toJson(it), ContentType.Application.Json)
+    install(ContentNegotiation){
+        register(ContentType.Application.Json, GsonConverter())
     }
 
-    routing {
+    install(Routing) {
         index(storage)
         postThought(storage, ::hash)
         delete(storage, ::hash)
@@ -48,5 +45,4 @@ fun Application.main() {
         login(storage, ::hash)
         register(storage, ::hash)
     }
-}
-
+}
\ No newline at end of file
diff --git a/backend/src/org/jetbrains/demo/thinkter/ApplicationPage.kt b/backend/src/org/jetbrains/demo/thinkter/ApplicationPage.kt
index 7479793..0278064 100644
--- a/backend/src/org/jetbrains/demo/thinkter/ApplicationPage.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/ApplicationPage.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.demo.thinkter
 
 import kotlinx.html.*
-import org.jetbrains.ktor.html.*
+import io.ktor.html.*
 
 class ApplicationPage : Template<HTML> {
     val caption = Placeholder<TITLE>()
diff --git a/backend/src/org/jetbrains/demo/thinkter/Delete.kt b/backend/src/org/jetbrains/demo/thinkter/Delete.kt
index 21254fb..6d37dd0 100644
--- a/backend/src/org/jetbrains/demo/thinkter/Delete.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/Delete.kt
@@ -1,16 +1,22 @@
 package org.jetbrains.demo.thinkter
 
-import org.jetbrains.demo.thinkter.dao.*
-import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.routing.*
-import org.jetbrains.ktor.sessions.*
+import io.ktor.application.call
+import io.ktor.http.HttpStatusCode
+import io.ktor.locations.get
+import io.ktor.locations.post
+import io.ktor.request.receive
+import io.ktor.response.respond
+import io.ktor.routing.Route
+import io.ktor.sessions.get
+import io.ktor.sessions.sessions
+import io.ktor.util.ValuesMap
+import org.jetbrains.demo.thinkter.dao.ThinkterStorage
+import org.jetbrains.demo.thinkter.model.PostThoughtToken
+import org.jetbrains.demo.thinkter.model.RpcData
 
 fun Route.delete(dao: ThinkterStorage, hashFunction: (String) -> String) {
     get<ThoughtDelete> {
-        val user = call.sessionOrNull<Session>()?.let { dao.user(it.userId) }
+        val user = call.sessions.get<Session>()?.let { dao.user(it.userId) }
         val date = System.currentTimeMillis()
 
         if (user == null) {
@@ -22,10 +28,14 @@ fun Route.delete(dao: ThinkterStorage, hashFunction: (String) -> String) {
     }
 
     post<ThoughtDelete> {
-        val user = call.sessionOrNull<Session>()?.let { dao.user(it.userId) }
+        val user = call.sessions.get<Session>()?.let { dao.user(it.userId) }
         val thought = dao.getThought(it.id)
 
-        if (user == null || thought.userId != user.userId || !call.verifyCode(it.date, user, it.code, hashFunction)) {
+        val form = call.receive<ValuesMap>()
+        val date = form["date"]?.toLong() ?: -1
+        val code = form["code"] ?: ""
+
+        if (user == null || thought.userId != user.userId || !call.verifyCode(date, user, code, hashFunction)) {
             call.respond(HttpStatusCode.Forbidden)
         } else {
             dao.deleteThought(it.id)
diff --git a/backend/src/org/jetbrains/demo/thinkter/Index.kt b/backend/src/org/jetbrains/demo/thinkter/Index.kt
index 63ece58..90aafdd 100644
--- a/backend/src/org/jetbrains/demo/thinkter/Index.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/Index.kt
@@ -2,36 +2,35 @@ package org.jetbrains.demo.thinkter
 
 import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.html.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.response.*
-import org.jetbrains.ktor.routing.*
-import org.jetbrains.ktor.sessions.*
+import io.ktor.application.*
+import io.ktor.html.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.contentType
+import io.ktor.response.*
+import io.ktor.routing.*
+import io.ktor.sessions.*
 import java.time.*
 
 fun Route.index(storage: ThinkterStorage) {
-    contentType(ContentType.Text.Html) {
-        get<Index> {
-            call.respondHtmlTemplate(ApplicationPage()) {
-                caption { +"Thinkter" }
-            }
-        }
-    }
-    contentType(ContentType.Application.Json) {
-        get<Index> {
-            val user = call.sessionOrNull<Session>()?.let { storage.user(it.userId) }
-            val top = storage.top(10).map(storage::getThought)
-            val latest = storage.latest(10).map(storage::getThought)
+    get<Index> {
+        val user = call.sessions.get<Session>()?.let { storage.user(it.userId) }
+        val top = storage.top(10).map(storage::getThought)
+        val latest = storage.latest(10).map(storage::getThought)
 
-            call.response.pipeline.intercept(ApplicationResponsePipeline.After) {
+        if(call.request.contentType().match(ContentType.Application.Json)) {
+            call.response.pipeline.intercept(ApplicationSendPipeline.After) {
                 val etagString = user?.userId + "," + top.joinToString { it.id.toString() } + latest.joinToString { it.id.toString() }
                 call.response.etag(etagString)
             }
 
             call.respond(IndexResponse(top, latest))
+        }else{
+            call.respondHtmlTemplate(ApplicationPage()) {
+                caption { +"Thinkter" }
+            }
         }
+    }
         get<Poll> { poll ->
             if (poll.lastTime.isBlank()) {
                 call.respond(PollResponse(System.currentTimeMillis(), "0"))
@@ -44,7 +43,6 @@ fun Route.index(storage: ThinkterStorage) {
                 call.respond(PollResponse(time, if (count == 10) "10+" else count.toString()))
             }
         }
-    }
 }
 
 private fun Thought.toEpochMilli() = LocalDateTime.parse(date).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli()
diff --git a/backend/src/org/jetbrains/demo/thinkter/Locations.kt b/backend/src/org/jetbrains/demo/thinkter/Locations.kt
index 7b3a668..d7cb326 100644
--- a/backend/src/org/jetbrains/demo/thinkter/Locations.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/Locations.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.demo.thinkter
 
-import org.jetbrains.ktor.locations.*
+import io.ktor.locations.*
 
 
 @location("/")
@@ -13,7 +13,7 @@ class Poll(val lastTime: String = "")
 data class PostThought(val text: String = "", val date: Long = 0L, val code: String = "", val replyTo: Int? = null)
 
 @location("/thought/{id}/delete")
-data class ThoughtDelete(val id: Int, val date: Long, val code: String)
+data class ThoughtDelete(val id: Int)
 
 @location("/thought/{id}")
 data class ViewThought(val id: Int)
diff --git a/backend/src/org/jetbrains/demo/thinkter/Login.kt b/backend/src/org/jetbrains/demo/thinkter/Login.kt
index acaffd1..d7a5916 100644
--- a/backend/src/org/jetbrains/demo/thinkter/Login.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/Login.kt
@@ -2,15 +2,18 @@ package org.jetbrains.demo.thinkter
 
 import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.routing.*
-import org.jetbrains.ktor.sessions.*
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.receive
+import io.ktor.response.respond
+import io.ktor.sessions.*
+import io.ktor.routing.Route
+import io.ktor.util.ValuesMap
 
 fun Route.login(dao: ThinkterStorage, hash: (String) -> String) {
     get<Login> {
-        val user = call.sessionOrNull<Session>()?.let { dao.user(it.userId) }
+        val user = call.sessions.get<Session>()?.let { dao.user(it.userId) }
         if (user == null) {
             call.respond(HttpStatusCode.Forbidden)
         } else {
@@ -18,22 +21,26 @@ fun Route.login(dao: ThinkterStorage, hash: (String) -> String) {
         }
     }
     post<Login> {
+        val form = call.receive<ValuesMap>()
+        val userId = form["userId"] ?: ""
+        val password = form["password"] ?: ""
+
         val login = when {
-            it.userId.length < 4 -> null
-            it.password.length < 6 -> null
-            !userNameValid(it.userId) -> null
-            else -> dao.user(it.userId, hash(it.password))
+            userId.length < 4 -> null
+            password.length < 6 -> null
+            !userNameValid(userId) -> null
+            else -> dao.user(userId, hash(password))
         }
 
         if (login == null) {
             call.respond(LoginResponse(error = "Invalid username or password"))
         } else {
-            call.session(Session(login.userId))
+            call.sessions.set(Session(login.userId))
             call.respond(LoginResponse(login))
         }
     }
     post<Logout> {
-        call.clearSession()
+        call.sessions.clear<Session>()
         call.respond(HttpStatusCode.OK)
     }
 }
diff --git a/backend/src/org/jetbrains/demo/thinkter/PostThought.kt b/backend/src/org/jetbrains/demo/thinkter/PostThought.kt
index f4153f6..4ba4e46 100644
--- a/backend/src/org/jetbrains/demo/thinkter/PostThought.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/PostThought.kt
@@ -2,15 +2,18 @@ package org.jetbrains.demo.thinkter
 
 import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.routing.*
-import org.jetbrains.ktor.sessions.*
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.receive
+import io.ktor.response.respond
+import io.ktor.routing.*
+import io.ktor.sessions.*
+import io.ktor.util.ValuesMap
 
 fun Route.postThought(dao: ThinkterStorage, hashFunction: (String) -> String) {
     get<PostThought> {
-        val user = call.sessionOrNull<Session>()?.let { dao.user(it.userId) }
+        val user = call.sessions.get<Session>()?.let { dao.user(it.userId) }
 
         if (user == null) {
             call.respond(HttpStatusCode.Forbidden)
@@ -20,12 +23,20 @@ fun Route.postThought(dao: ThinkterStorage, hashFunction: (String) -> String) {
             call.respond(PostThoughtToken(user.userId, date, code))
         }
     }
+
     post<PostThought> {
-        val user = call.sessionOrNull<Session>()?.let { dao.user(it.userId) }
-        if (user == null || !call.verifyCode(it.date, user, it.code, hashFunction)) {
+        val form = call.receive<ValuesMap>()
+        val userId = form["userId"] ?: ""
+        val date = form["date"]?.toLong() ?: -1
+        val code = form["code"] ?: ""
+        val text = form["text"] ?: ""
+        val replyTo = form["replyTo"]?.toInt()
+
+        val user = call.sessions.get<Session>()?.let { dao.user(it.userId) }
+        if (user == null || !call.verifyCode(date, user, code, hashFunction)) {
             call.respond(HttpStatusCode.Forbidden)
         } else {
-            val id = dao.createThought(user.userId, it.text, it.replyTo)
+            val id = dao.createThought(user.userId, text, replyTo)
             call.respond(PostThoughtResult(dao.getThought(id)))
         }
     }
diff --git a/backend/src/org/jetbrains/demo/thinkter/Register.kt b/backend/src/org/jetbrains/demo/thinkter/Register.kt
index 0752763..0fc7cfe 100644
--- a/backend/src/org/jetbrains/demo/thinkter/Register.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/Register.kt
@@ -2,47 +2,53 @@ package org.jetbrains.demo.thinkter
 
 import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.routing.*
-import org.jetbrains.ktor.sessions.*
-import org.jetbrains.ktor.util.*
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.receive
+import io.ktor.response.respond
+import io.ktor.routing.*
+import io.ktor.sessions.*
+import io.ktor.util.ValuesMap
 
 fun Route.register(dao: ThinkterStorage, hashFunction: (String) -> String) {
-    post<Register> { form ->
-        val vm = call.request.content.get<ValuesMap>()
+    post<Register> {
+        val form = call.receive<ValuesMap>()
+        val userId = form["userId"] ?: ""
+        val password = form["password"] ?: ""
+        val displayName = form["displayName"] ?: ""
+        val email = form["email"] ?: ""
+        val user = call.sessions.get<Session>()?.let { dao.user(it.userId) }
 
-        val user = call.sessionOrNull<Session>()?.let { dao.user(it.userId) }
         if (user != null) {
             call.redirect(LoginResponse(user))
         } else {
-            if (form.password.length < 6) {
+            if (password.length < 6) {
                 call.respond(LoginResponse(error = "Password should be at least 6 characters long"))
-            } else if (form.userId.length < 4) {
+            } else if (userId.length < 4) {
                 call.respond(LoginResponse(error = "Login should be at least 4 characters long"))
-            } else if (!userNameValid(form.userId)) {
+            } else if (!userNameValid(userId)) {
                 call.respond(LoginResponse(error = "Login should be consists of digits, letters, dots or underscores"))
-            } else if (dao.user(form.userId) != null) {
+            } else if (dao.user(userId) != null) {
                 call.respond(LoginResponse(error = "User with the following login is already registered"))
             } else {
-                val hash = hashFunction(form.password)
-                val newUser = User(form.userId, form.email, form.displayName, hash)
+                val hash = hashFunction(password)
+                val newUser = User(userId, email, displayName, hash)
 
                 try {
                     dao.createUser(newUser)
                 } catch (e: Throwable) {
-                    if (dao.user(form.userId) != null) {
+                    if (dao.user(userId) != null) {
                         call.respond(LoginResponse(error = "User with the following login is already registered"))
-                    } else if (dao.userByEmail(form.email) != null) {
-                        call.respond(LoginResponse(error = "User with the following email ${form.email} is already registered"))
+                    } else if (dao.userByEmail(email) != null) {
+                        call.respond(LoginResponse(error = "User with the following email ${email} is already registered"))
                     } else {
                         application.environment.log.error("Failed to register user", e)
                         call.respond(LoginResponse(error = "Failed to register"))
                     }
                 }
 
-                call.session(Session(newUser.userId))
+                call.sessions.set(Session(newUser.userId))
                 call.respond(LoginResponse(newUser))
             }
         }
diff --git a/backend/src/org/jetbrains/demo/thinkter/UserPage.kt b/backend/src/org/jetbrains/demo/thinkter/UserPage.kt
index a97c0e9..4bc1c14 100644
--- a/backend/src/org/jetbrains/demo/thinkter/UserPage.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/UserPage.kt
@@ -2,10 +2,11 @@ package org.jetbrains.demo.thinkter
 
 import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.routing.*
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.response.respond
+import io.ktor.routing.*
 
 fun Route.userPage(dao: ThinkterStorage) {
     get<UserThoughts> {
diff --git a/backend/src/org/jetbrains/demo/thinkter/Utilities.kt b/backend/src/org/jetbrains/demo/thinkter/Utilities.kt
index 315983b..22c6f10 100644
--- a/backend/src/org/jetbrains/demo/thinkter/Utilities.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/Utilities.kt
@@ -1,13 +1,12 @@
 package org.jetbrains.demo.thinkter
 
-import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.request.*
-import org.jetbrains.ktor.response.*
-import org.jetbrains.ktor.util.*
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.*
+import io.ktor.response.*
+import io.ktor.util.*
 import java.net.*
 import java.util.concurrent.*
 import javax.crypto.*
diff --git a/backend/src/org/jetbrains/demo/thinkter/ViewThought.kt b/backend/src/org/jetbrains/demo/thinkter/ViewThought.kt
index 9a58018..1c45a6e 100644
--- a/backend/src/org/jetbrains/demo/thinkter/ViewThought.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/ViewThought.kt
@@ -2,14 +2,15 @@ package org.jetbrains.demo.thinkter
 
 import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.routing.*
-import org.jetbrains.ktor.sessions.*
+import io.ktor.application.*
+import io.ktor.locations.*
+import io.ktor.response.respond
+import io.ktor.routing.*
+import io.ktor.sessions.*
 
 fun Route.viewThought(dao: ThinkterStorage, hashFunction: (String) -> String) {
     get<ViewThought> {
-        val user = call.sessionOrNull<Session>()?.let { dao.user(it.userId) }
+        val user = call.sessions.get<Session>()?.let { dao.user(it.userId) }
         val date = System.currentTimeMillis()
         val code = if (user != null) call.securityCode(date, user, hashFunction) else null
 
diff --git a/build.gradle b/build.gradle
index 7011b27..8036aee 100644
--- a/build.gradle
+++ b/build.gradle
@@ -21,12 +21,13 @@ subprojects { p ->
 subprojects {
     ext.kotlin_version = "1.1.51"
     ext.html_version = "0.6.4"
-    ext.ktor_version = "0.3.0"
+    ext.ktor_version = "0.9.0"
     ext.squash_version = "0.2.2"
 
     repositories {
         mavenLocal()
         jcenter()
+        maven { url "https://dl.bintray.com/kotlin/kotlinx/" }
         maven { url "http://dl.bintray.com/kotlin/kotlinx.html" }
         maven { url "http://dl.bintray.com/kotlin/ktor" }
         maven { url "https://dl.bintray.com/kotlin/squash" }
diff --git a/frontend/src/org/jetbrains/demo/thinkter/Rpc.kt b/frontend/src/org/jetbrains/demo/thinkter/Rpc.kt
index 11bea90..7bdd556 100644
--- a/frontend/src/org/jetbrains/demo/thinkter/Rpc.kt
+++ b/frontend/src/org/jetbrains/demo/thinkter/Rpc.kt
@@ -8,10 +8,10 @@ import kotlin.browser.*
 import kotlin.js.*
 
 suspend fun index(): IndexResponse =
-    getAndParseResult("/", null, ::parseIndexResponse)
+    getAndParseResult("/", "application/json", null, ::parseIndexResponse)
 
 suspend fun register(userId: String, password: String, displayName: String, email: String): User =
-    postAndParseResult("/register", URLSearchParams().apply {
+    postAndParseResult("/register", "application/x-www-form-urlencoded", URLSearchParams().apply {
         append("userId", userId)
         append("password", password)
         append("displayName", displayName)
@@ -19,24 +19,24 @@ suspend fun register(userId: String, password: String, displayName: String, emai
     }, ::parseLoginOrRegisterResponse)
 
 suspend fun pollFromLastTime(lastTime: String = ""): String =
-    getAndParseResult<String>("/poll?lastTime=$lastTime", null, { json ->
+    getAndParseResult<String>("/poll?lastTime=$lastTime", "application/x-www-form-urlencoded", null, { json ->
         json.count
     })
 
 suspend fun checkSession(): User =
-    getAndParseResult("/login", null, ::parseLoginOrRegisterResponse)
+    getAndParseResult("/login", "application/json", null, ::parseLoginOrRegisterResponse)
 
 suspend fun login(userId: String, password: String): User =
-    postAndParseResult("/login", URLSearchParams().apply {
+    postAndParseResult("/login", "application/x-www-form-urlencoded", URLSearchParams().apply {
         append("userId", userId)
         append("password", password)
     }, ::parseLoginOrRegisterResponse)
 
 suspend fun postThoughtPrepare(): PostThoughtToken =
-    getAndParseResult("/post-new", null, ::parseNewPostTokenResponse)
+    getAndParseResult("/post-new", "application/json", null, ::parseNewPostTokenResponse)
 
 suspend fun postThought(replyTo: Int?, text: String, token: PostThoughtToken): Thought =
-    postAndParseResult("/post-new", URLSearchParams().apply {
+    postAndParseResult("/post-new", "application/x-www-form-urlencoded", URLSearchParams().apply {
         append("text", text)
         append("date", token.date.toString())
         append("code", token.code)
@@ -53,7 +53,7 @@ suspend fun logoutUser() {
 }
 
 suspend fun deleteThought(id: Int, date: Long, code: String) =
-    postAndParseResult("/thought/$id/delete", URLSearchParams().apply {
+    postAndParseResult("/thought/$id/delete", "application/x-www-form-urlencoded", URLSearchParams().apply {
         append("date", date.toString())
         append("code", code)
     }, { Unit })
@@ -87,18 +87,18 @@ private fun parseLoginOrRegisterResponse(json: dynamic): User {
 
 class LoginOrRegisterFailedException(message: String) : Throwable(message)
 
-suspend fun <T> postAndParseResult(url: String, body: dynamic, parse: (dynamic) -> T): T =
-    requestAndParseResult("POST", url, body, parse)
+suspend fun <T> postAndParseResult(url: String, contentType: String, body: dynamic, parse: (dynamic) -> T): T =
+    requestAndParseResult("POST", url, body, contentType, parse)
 
-suspend fun <T> getAndParseResult(url: String, body: dynamic, parse: (dynamic) -> T): T =
-    requestAndParseResult("GET", url, body, parse)
+suspend fun <T> getAndParseResult(url: String, contentType: String, body: dynamic, parse: (dynamic) -> T): T =
+    requestAndParseResult("GET", url, body, contentType, parse)
 
-suspend fun <T> requestAndParseResult(method: String, url: String, body: dynamic, parse: (dynamic) -> T): T {
+suspend fun <T> requestAndParseResult(method: String, url: String, body: dynamic, contentType: String, parse: (dynamic) -> T): T {
     val response = window.fetch(url, object: RequestInit {
         override var method: String? = method
         override var body: dynamic = body
         override var credentials: RequestCredentials? = "same-origin".asDynamic()
-        override var headers: dynamic = json("Accept" to "application/json")
+        override var headers: dynamic = json("Content-Type" to contentType)
     }).await()
     return parse(response.json().await())
-}
+}
\ No newline at end of file