diff --git a/Cargo.toml b/Cargo.toml
index 31ac6a77..56cdf43a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,26 +11,26 @@ repository = "https://github.com/ruma/ruma-api-macros"
 version = "0.2.2"
 
 [dependencies]
-quote = "0.5.2"
-ruma-api = "0.5.0"
+quote = "0.6"
+ruma-api = "0.5"
 
 [dependencies.syn]
-version = "0.13.10"
+version = "0.14"
 features = ["full"]
 
 [dependencies.proc-macro2]
-version = "0.4.2"
+version = "0.4"
 features = ["nightly"]
 
 [dev-dependencies]
-futures = "0.1.21"
-http = "0.1.5"
+futures = "0.1"
+http = "0.1"
 hyper = "0.12"
-serde = "1.0.57"
-serde_derive = "1.0.57"
-serde_json = "1.0.17"
-serde_urlencoded = "0.5.2"
-url = "1.7.0"
+serde = "1.0"
+serde_derive = "1.0"
+serde_json = "1.0"
+serde_urlencoded = "0.5"
+url = "1.7"
 
 [lib]
 proc-macro = true
diff --git a/src/api/metadata.rs b/src/api/metadata.rs
index c167829d..2684aab3 100644
--- a/src/api/metadata.rs
+++ b/src/api/metadata.rs
@@ -25,7 +25,7 @@ impl From<Vec<FieldValue>> for Metadata {
                 _ => panic!("expected Member::Named"),
             };
 
-            match identifier.as_ref() {
+            match identifier.to_string().as_ref() {
                 "description" => {
                     let expr_lit = match field_value.expr {
                         Expr::Lit(expr_lit) => expr_lit,
diff --git a/src/api/mod.rs b/src/api/mod.rs
index e7c84d61..a7737f6d 100644
--- a/src/api/mod.rs
+++ b/src/api/mod.rs
@@ -1,4 +1,5 @@
-use quote::{ToTokens, Tokens};
+use proc_macro2::{Span, TokenStream};
+use quote::{ToTokens, TokenStreamExt};
 use syn::punctuated::Punctuated;
 use syn::synom::Synom;
 use syn::{Field, FieldValue, Ident, Meta};
@@ -23,7 +24,7 @@ pub fn strip_serde_attrs(field: &Field) -> Field {
             _ => return true,
         };
 
-        if meta_list.ident.as_ref() == "serde" {
+        if meta_list.ident == "serde" {
             return false;
         }
 
@@ -50,9 +51,9 @@ impl From<RawApi> for Api {
 }
 
 impl ToTokens for Api {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let description = &self.metadata.description;
-        let method = Ident::from(self.metadata.method.as_ref());
+        let method = Ident::new(self.metadata.method.as_ref(), Span::call_site());
         let name = &self.metadata.name;
         let path = &self.metadata.path;
         let rate_limited = &self.metadata.rate_limited;
@@ -92,7 +93,7 @@ impl ToTokens for Api {
 
                 if segment.starts_with(':') {
                     let path_var = &segment[1..];
-                    let path_var_ident = Ident::from(path_var);
+                    let path_var_ident = Ident::new(path_var, Span::call_site());
 
                     tokens.append_all(quote! {
                         (&request_path.#path_var_ident.to_string());
@@ -122,7 +123,7 @@ impl ToTokens for Api {
                 url.set_query(Some(&::serde_urlencoded::to_string(request_query)?));
             }
         } else {
-            Tokens::new()
+            TokenStream::new()
         };
 
         let add_headers_to_request = if self.request.has_header_fields() {
@@ -134,11 +135,11 @@ impl ToTokens for Api {
 
             header_tokens
         } else {
-            Tokens::new()
+            TokenStream::new()
         };
 
         let create_http_request = if let Some(field) = self.request.newtype_body_field() {
-            let field_name = field.ident.expect("expected field to have an identifier");
+            let field_name = field.ident.as_ref().expect("expected field to have an identifier");
 
             quote! {
                 let request_body = RequestBody(request.#field_name);
@@ -202,13 +203,13 @@ impl ToTokens for Api {
                 let mut headers = http_response.headers().clone();
             }
         } else {
-            Tokens::new()
+            TokenStream::new()
         };
 
         let response_init_fields = if self.response.has_fields() {
             self.response.init_fields()
         } else {
-            Tokens::new()
+            TokenStream::new()
         };
 
         tokens.append_all(quote! {
diff --git a/src/api/request.rs b/src/api/request.rs
index be33d5be..d8272053 100644
--- a/src/api/request.rs
+++ b/src/api/request.rs
@@ -1,4 +1,5 @@
-use quote::{ToTokens, Tokens};
+use proc_macro2::{Span, TokenStream};
+use quote::{TokenStreamExt, ToTokens};
 use syn::spanned::Spanned;
 use syn::{Field, Ident, Lit, Meta, NestedMeta};
 
@@ -9,15 +10,15 @@ pub struct Request {
 }
 
 impl Request {
-    pub fn add_headers_to_request(&self) -> Tokens {
-        self.header_fields().fold(Tokens::new(), |mut header_tokens, request_field| {
+    pub fn add_headers_to_request(&self) -> TokenStream {
+        self.header_fields().fold(TokenStream::new(), |mut header_tokens, request_field| {
             let (field, header_name_string) = match request_field {
                 RequestField::Header(field, header_name_string) => (field, header_name_string),
                 _ => panic!("expected request field to be header variant"),
             };
 
             let field_name = &field.ident;
-            let header_name = Ident::from(header_name_string.as_ref());
+            let header_name = Ident::new(header_name_string.as_ref(), Span::call_site());
 
             header_tokens.append_all(quote! {
                 headers.append(
@@ -67,23 +68,23 @@ impl Request {
         None
     }
 
-    pub fn request_body_init_fields(&self) -> Tokens {
+    pub fn request_body_init_fields(&self) -> TokenStream {
         self.struct_init_fields(RequestFieldKind::Body)
     }
 
-    pub fn request_path_init_fields(&self) -> Tokens {
+    pub fn request_path_init_fields(&self) -> TokenStream {
         self.struct_init_fields(RequestFieldKind::Path)
     }
 
-    pub fn request_query_init_fields(&self) -> Tokens {
+    pub fn request_query_init_fields(&self) -> TokenStream {
         self.struct_init_fields(RequestFieldKind::Query)
     }
 
-    fn struct_init_fields(&self, request_field_kind: RequestFieldKind) -> Tokens {
-        let mut tokens = Tokens::new();
+    fn struct_init_fields(&self, request_field_kind: RequestFieldKind) -> TokenStream {
+        let mut tokens = TokenStream::new();
 
         for field in self.fields.iter().flat_map(|f| f.field_(request_field_kind)) {
-            let field_name = field.ident.expect("expected field to have an identifier");
+            let field_name = field.ident.as_ref().expect("expected field to have an identifier");
             let span = field.span();
 
             tokens.append_all(quote_spanned! {span=>
@@ -112,7 +113,7 @@ impl From<Vec<Field>> for Request {
                     _ => return true,
                 };
 
-                if meta_list.ident.as_ref() != "ruma_api" {
+                if meta_list.ident != "ruma_api" {
                     return true;
                 }
 
@@ -121,7 +122,7 @@ impl From<Vec<Field>> for Request {
                         NestedMeta::Meta(meta_item) => {
                             match meta_item {
                                 Meta::Word(ident) => {
-                                    match ident.as_ref() {
+                                    match ident.to_string().as_ref() {
                                         "body" => {
                                             has_newtype_body = true;
                                             field_kind = RequestFieldKind::NewtypeBody;
@@ -132,7 +133,7 @@ impl From<Vec<Field>> for Request {
                                     }
                                 }
                                 Meta::NameValue(name_value) => {
-                                    match name_value.ident.as_ref() {
+                                    match name_value.ident.to_string().as_ref() {
                                         "header" => {
                                             match name_value.lit {
                                                 Lit::Str(lit_str) => header = Some(lit_str.value()),
@@ -173,7 +174,7 @@ impl From<Vec<Field>> for Request {
 }
 
 impl ToTokens for Request {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let request_struct_header = quote! {
             /// Data for a request to this API endpoint.
             #[derive(Debug)]
@@ -183,7 +184,7 @@ impl ToTokens for Request {
         let request_struct_body = if self.fields.len() == 0 {
             quote!(;)
         } else {
-            let fields = self.fields.iter().fold(Tokens::new(), |mut field_tokens, request_field| {
+            let fields = self.fields.iter().fold(TokenStream::new(), |mut field_tokens, request_field| {
                 let field = request_field.field();
                 let span = field.span();
 
@@ -214,7 +215,7 @@ impl ToTokens for Request {
                 struct RequestBody(#ty);
             };
         } else if self.has_body_fields() {
-            let fields = self.fields.iter().fold(Tokens::new(), |mut field_tokens, request_field| {
+            let fields = self.fields.iter().fold(TokenStream::new(), |mut field_tokens, request_field| {
                 match *request_field {
                     RequestField::Body(ref field) => {
                         let span = field.span();
@@ -235,13 +236,13 @@ impl ToTokens for Request {
                 }
             };
         } else {
-            request_body_struct = Tokens::new();
+            request_body_struct = TokenStream::new();
         }
 
         let request_path_struct;
 
         if self.has_path_fields() {
-            let fields = self.fields.iter().fold(Tokens::new(), |mut field_tokens, request_field| {
+            let fields = self.fields.iter().fold(TokenStream::new(), |mut field_tokens, request_field| {
                 match *request_field {
                     RequestField::Path(ref field) => {
                         let span = field.span();
@@ -262,13 +263,13 @@ impl ToTokens for Request {
                 }
             };
         } else {
-            request_path_struct = Tokens::new();
+            request_path_struct = TokenStream::new();
         }
 
         let request_query_struct;
 
         if self.has_query_fields() {
-            let fields = self.fields.iter().fold(Tokens::new(), |mut field_tokens, request_field| {
+            let fields = self.fields.iter().fold(TokenStream::new(), |mut field_tokens, request_field| {
                 match *request_field {
                     RequestField::Query(ref field) => {
                         let span = field.span();
@@ -289,7 +290,7 @@ impl ToTokens for Request {
                 }
             };
         } else {
-            request_query_struct = Tokens::new();
+            request_query_struct = TokenStream::new();
         }
 
         tokens.append_all(quote! {
diff --git a/src/api/response.rs b/src/api/response.rs
index 39658f1f..3d879f6f 100644
--- a/src/api/response.rs
+++ b/src/api/response.rs
@@ -1,4 +1,5 @@
-use quote::{ToTokens, Tokens};
+use proc_macro2::{Span, TokenStream};
+use quote::{ToTokens, TokenStreamExt};
 use syn::spanned::Spanned;
 use syn::{Field, Ident, Lit, Meta, NestedMeta};
 
@@ -21,13 +22,13 @@ impl Response {
         self.fields.iter().any(|field| field.is_header())
     }
 
-    pub fn init_fields(&self) -> Tokens {
-        let mut tokens = Tokens::new();
+    pub fn init_fields(&self) -> TokenStream {
+        let mut tokens = TokenStream::new();
 
         for response_field in self.fields.iter() {
             match *response_field {
                 ResponseField::Body(ref field) => {
-                    let field_name = field.ident.expect("expected field to have an identifier");
+                    let field_name = field.ident.as_ref().expect("expected field to have an identifier");
                     let span = field.span();
 
                     tokens.append_all(quote_spanned! {span=>
@@ -35,8 +36,8 @@ impl Response {
                     });
                 }
                 ResponseField::Header(ref field, ref header) => {
-                    let field_name = field.ident.expect("expected field to have an identifier");
-                    let header_name = Ident::from(header.as_ref());
+                    let field_name = field.ident.as_ref().expect("expected field to have an identifier");
+                    let header_name = Ident::new(header.as_ref(), Span::call_site());
                     let span = field.span();
 
                     tokens.append_all(quote_spanned! {span=>
@@ -48,7 +49,7 @@ impl Response {
                     });
                 }
                 ResponseField::NewtypeBody(ref field) => {
-                    let field_name = field.ident.expect("expected field to have an identifier");
+                    let field_name = field.ident.as_ref().expect("expected field to have an identifier");
                     let span = field.span();
 
                     tokens.append_all(quote_spanned! {span=>
@@ -94,7 +95,7 @@ impl From<Vec<Field>> for Response {
                     _ => return true,
                 };
 
-                if meta_list.ident.as_ref() != "ruma_api" {
+                if meta_list.ident != "ruma_api" {
                     return true;
                 }
 
@@ -103,7 +104,7 @@ impl From<Vec<Field>> for Response {
                         NestedMeta::Meta(meta_item) => {
                             match meta_item {
                                 Meta::Word(ident) => {
-                                    match ident.as_ref() {
+                                    match ident.to_string().as_ref() {
                                         "body" => {
                                             has_newtype_body = true;
                                             field_kind = ResponseFieldKind::NewtypeBody;
@@ -112,7 +113,7 @@ impl From<Vec<Field>> for Response {
                                     }
                                 }
                                 Meta::NameValue(name_value) => {
-                                    match name_value.ident.as_ref() {
+                                    match name_value.ident.to_string().as_ref() {
                                         "header" => {
                                             match name_value.lit {
                                                 Lit::Str(lit_str) => header = Some(lit_str.value()),
@@ -156,7 +157,7 @@ impl From<Vec<Field>> for Response {
 }
 
 impl ToTokens for Response {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let response_struct_header = quote! {
             /// Data in the response from this API endpoint.
             #[derive(Debug)]
@@ -166,7 +167,7 @@ impl ToTokens for Response {
         let response_struct_body = if self.fields.len() == 0 {
             quote!(;)
         } else {
-            let fields = self.fields.iter().fold(Tokens::new(), |mut fields_tokens, response_field| {
+            let fields = self.fields.iter().fold(TokenStream::new(), |mut fields_tokens, response_field| {
                 let field = response_field.field();
                 let span = field.span();
 
@@ -197,7 +198,7 @@ impl ToTokens for Response {
                 struct ResponseBody(#ty);
             };
         } else if self.has_body_fields() {
-            let fields = self.fields.iter().fold(Tokens::new(), |mut field_tokens, response_field| {
+            let fields = self.fields.iter().fold(TokenStream::new(), |mut field_tokens, response_field| {
                 match *response_field {
                     ResponseField::Body(ref field) => {
                         let span = field.span();
@@ -218,7 +219,7 @@ impl ToTokens for Response {
                 }
             };
         } else {
-            response_body_struct = Tokens::new();
+            response_body_struct = TokenStream::new();
         }
 
         tokens.append_all(quote! {
diff --git a/src/lib.rs b/src/lib.rs
index 4a90c685..126a60ba 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -8,6 +8,7 @@
 #![recursion_limit="256"]
 
 extern crate proc_macro;
+extern crate proc_macro2;
 #[macro_use] extern crate quote;
 extern crate ruma_api;
 #[macro_use] extern crate syn;
@@ -207,5 +208,5 @@ pub fn ruma_api(input: TokenStream) -> TokenStream {
 
     let api = Api::from(raw_api);
 
-    api.into_tokens().into()
+    api.into_token_stream().into()
 }