POST request with a simple string in body with Alamofire

how is it possible to send a POST request with a simple string in the HTTP body with Alamofire in my iOS app?

As default Alamofire needs parameters for a request:

  • Using manager.request with POST
  • Live search throttle in Swift 3
  • How to make NSURLRequest to obtain a Twitter request token?
  • Why does Unexpected non-void return value in void function happen?
  • Alamofire POST request with progress
  • Swift 3- Update UI from main thread
  • Alamofire.request(.POST, "http://mywebsite.com/post-request", parameters: ["foo": "bar"])
    

    These parameters contain key-value-pairs. But I don’t want to send a request with a key-value string in the HTTP body.

    I mean something like this:

    Alamofire.request(.POST, "http://mywebsite.com/post-request", body: "myBodyString")
    

    8 Solutions Collect From Internet About “POST request with a simple string in body with Alamofire”

    Your example Alamofire.request(.POST, "http://mywebsite.com/post-request", parameters: ["foo": "bar"]) already contains “foo=bar” string as its body.
    But if you really want string with custom format. You can do this:

    Alamofire.request(.POST, "http://mywebsite.com/post-request", parameters: [:], encoding: .Custom({
                (convertible, params) in
                var mutableRequest = convertible.URLRequest.copy() as NSMutableURLRequest
                mutableRequest.HTTPBody = "myBodyString".dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)
                return (mutableRequest, nil)
            }))
    

    Note: parameters should not be nil

    UPDATE (Alamofire 4.0, Swift 3.0):

    In Alamofire 4.0 API has changed. So for custom encoding we need value/object which conforms to ParameterEncoding protocol.

    extension String: ParameterEncoding {
    
        public func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest {
            var request = try urlRequest.asURLRequest()
            request.httpBody = data(using: .utf8, allowLossyConversion: false)
            return request
        }
    
    }
    
    Alamofire.request("http://mywebsite.com/post-request", method: .post, parameters: [:], encoding: "myBody", headers: [:])
    

    You can do this:

    1. I created a separated request Alamofire object.
    2. Convert string to Data
    3. Put in httpBody the data

      var request = URLRequest(url: URL(string: url)!)
      request.httpMethod = HTTPMethod.post.rawValue
      request.setValue("application/json", forHTTPHeaderField: "Content-Type")
      
      let pjson = attendences.toJSONString(prettyPrint: false)
      let data = (pjson?.data(using: .utf8))! as Data
      
      request.httpBody = data
      
      Alamofire.request(request).responseJSON { (response) in
      
      
          print(response)
      
      }
      

    I modified @Silmaril’s answer to extend Alamofire’s Manager.
    This solution uses EVReflection to serialize an object directly:

    //Extend Alamofire so it can do POSTs with a JSON body from passed object
    extension Alamofire.Manager {
        public class func request(
            method: Alamofire.Method,
            _ URLString: URLStringConvertible,
              bodyObject: EVObject)
            -> Request
        {
            return Manager.sharedInstance.request(
                method,
                URLString,
                parameters: [:],
                encoding: .Custom({ (convertible, params) in
                    let mutableRequest = convertible.URLRequest.copy() as! NSMutableURLRequest
                    mutableRequest.HTTPBody = bodyObject.toJsonString().dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)
                    return (mutableRequest, nil)
                })
            )
        }
    }
    

    Then you can use it like this:

    Alamofire.Manager.request(.POST, endpointUrlString, bodyObject: myObjectToPost)
    

    If you use Alamofire, it is enough to encoding type to “URLEncoding.httpBody”

    With that, you can send your data as a string in the httpbody allthough you defined it json in your code.

    It worked for me..

    UPDATED for

      var url = "http://..."
        let _headers : HTTPHeaders = ["Content-Type":"application/x-www-form-urlencoded"]
        let params : Parameters = ["grant_type":"password","username":"mail","password":"pass"]
    
        let url =  NSURL(string:"url" as String)
    
        request(url, method: .post, parameters: params, encoding: URLEncoding.httpBody , headers: _headers).responseJSON(completionHandler: {
            response in response
    
            let jsonResponse = response.result.value as! NSDictionary
    
            if jsonResponse["access_token"] != nil
            {
                access_token = String(describing: jsonResponse["accesstoken"]!)
    
            }
    
        })
    

    If you want to post string as raw body in request

    return Alamofire.request(.POST, "http://mywebsite.com/post-request" , parameters: [:], encoding: .Custom({
                (convertible, params) in
                let mutableRequest = convertible.URLRequest.copy() as! NSMutableURLRequest
    
                let data = ("myBodyString" as NSString).dataUsingEncoding(NSUTF8StringEncoding)
                mutableRequest.HTTPBody = data
                return (mutableRequest, nil)
            }))
    
    func paramsFromJSON(json: String) -> [String : AnyObject]?
    {
        let objectData: NSData = (json.dataUsingEncoding(NSUTF8StringEncoding))!
        var jsonDict: [ String : AnyObject]!
        do {
            jsonDict = try NSJSONSerialization.JSONObjectWithData(objectData, options: .MutableContainers) as! [ String : AnyObject]
            return jsonDict
        } catch {
            print("JSON serialization failed:  \(error)")
            return nil
        }
    }
    
    let json = Mapper().toJSONString(loginJSON, prettyPrint: false)
    
    Alamofire.request(.POST, url + "/login", parameters: paramsFromJSON(json!), encoding: .JSON)
    

    I have done it for array from strings. This solution is adjusted for string in body.

    The “native” way from Alamofire 4:

    struct JSONStringArrayEncoding: ParameterEncoding {
    private let myString: String
    
    init(string: String) {
        self.myString = string
    }
    
    func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest {
        var urlRequest = urlRequest.urlRequest
    
          let data = myString.data(using: .utf8)!
    
        if urlRequest?.value(forHTTPHeaderField: "Content-Type") == nil {
            urlRequest?.setValue("application/json", forHTTPHeaderField: "Content-Type")
        }
    
        urlRequest?.httpBody = data
    
        return urlRequest!
    }}
    

    And then make your request with:

    Alamofire.request("your url string", method: .post, parameters: [:], encoding: JSONStringArrayEncoding.init(string: "My string for body"), headers: [:])
    

    Xcode 8.X , Swift 3.X

    Easy Use;

     let params:NSMutableDictionary? = ["foo": "bar"];
                let ulr =  NSURL(string:"http://mywebsite.com/post-request" as String)
                let request = NSMutableURLRequest(url: ulr! as URL)
                request.httpMethod = "POST"
                request.setValue("application/json", forHTTPHeaderField: "Content-Type")
                let data = try! JSONSerialization.data(withJSONObject: params!, options: JSONSerialization.WritingOptions.prettyPrinted)
    
                let json = NSString(data: data, encoding: String.Encoding.utf8.rawValue)
                if let json = json {
                    print(json)
                }
                request.httpBody = json!.data(using: String.Encoding.utf8.rawValue);
    
    
                Alamofire.request(request as! URLRequestConvertible)
                    .responseJSON { response in
                        // do whatever you want here
                       print(response.request)  
                       print(response.response) 
                       print(response.data) 
                       print(response.result)
    
                }