Latest 5.0.4
License MIT
Platforms ios 9.0
Dependencies Arrow, thenPromise, Alamofire
Frameworks Foundation



Language: Swift 2 3 and 4
Platform: iOS 8+
Carthage compatible
Cocoapods compatible
License: MIT
Build Status
codebeat badge
Release version


let ws = WS("")

ws.get("/users").then { json in
    // Get back some json o/

Because JSON apis are used in 99% of iOS Apps, this should be simple.
We developers should focus on our app logic rather than boilerplate code .
Less code is better code

Try it!

ws is part of freshOS iOS toolset. Try it in an example App ! Download Starter Project


By providing a lightweight client that automates boilerplate code everyone has to write.
By exposing a delightfully simple api to get the job done simply, clearly, quickly.
Getting swift models from a JSON api is now a problem of the past


  • [x] Build concise Apis
  • [x] Automatically maps your models
  • [x] Built-in network logger
  • [x] Stands on the shoulder of giants (Alamofire & Promises)
  • [x] Pure Swift, Simple & Lightweight



import ws // Import ws at the top of your file
import Arrow // Import Arrow to get access to the JSON type

class ViewController: UIViewController {

    // Set webservice base URL
    let ws = WS("")

    override func viewDidLoad() {

       // Get back some json instantly o/
       ws.get("/users").then { (json:JSON) in

Set up Model parsing

Create a User+JSON.swift file and map the JSON keys to your model properties

import Arrow

extension User: ArrowParsable {

    mutating func deserialize(_ json: JSON) {
        identifier <-- json["id"]
        username <-- json["username"]
        email <-- json["email"]

Note: ws uses Arrow for JSON Parsing

Choose what you want back

Here you are going to create a function that wraps your request.
There are different ways of writing that function depending on what you want back. An empty block, the JSON, the model or the array of models.

func voidCall() -> Promise<Void> {
    return ws.get("/users")

func jsonCall() -> Promise<JSON> {
    return ws.get("/users")

func singleModelCall() -> Promise<User> {
    return ws.get("/users/3")

func modelArrayCall() -> Promise<[User]> {
    return ws.get("/users")

As you can notice, only by changing the return type,
ws automatically knows what to do, for instance, try to parse the response into User models.

This enables us to stay concise without having to write extra code. o/

Note: ws uses then for Promises

Get it!

voidCall().then {

jsonCall().then { json in

singleModelCall().then { user in
    print(user) // Strongly typed User o/

modelArrayCall().then { users in
    print(users) // Strongly typed [User] o/


Want to log all network calls and responses ?

ws.logLevels = .debug

Want to hide network activity indicator ?

ws.showsNetworkActivityIndicator = false

Api Example

Here is a Typical CRUD example for Articles :

extension Article {

    static func list() -> Promise<[Article]> {
        return ws.get("/articles")

    func save() -> Promise<Article> {
        return"/articles", params: ["name":name])

    func fetch() -> Promise<Article> {
        return ws.get("/articles/(id)")

    func update() -> Promise<Void> {
        return ws.put("/articles/(id)", params: ["name":name])

    func delete() -> Promise<Void> {
        return ws.delete("/articles/(id)")


Here is how we use it in code :

// List Articles
Article.list().then { articles in


// Create Article
var newArticle = Article(name:"Cool story") { createdArticle in


// Fetch Article
var existingArticle = Article(id:42)
existingArticle.fetch().then { fetchedArticle in


// Edit Article = "My new name"
existingArticle.update().then {


// Delete Article
existingArticle.delete().then {


HTTP Status code

When a request fails, we often want to know the reason thanks to the HTTP status code.
Here is how to get it :

ws.get("/users").then {
    // Do something
}.onError { e in
    if let wsError = e as? WSError {
        print(wsError.status.rawValue) // RawValue for Int status

You can find the full WSError enum here ->

Bonus – Load More pattern

Very often we deal we lists and the ability to load more items.
Here we are going to see an example implementation of this pattern using ws.
This is not included because the logic itself depends on your backend implementation.
This will give you an example for you to roll out your own version.


import ws
import then
import Arrow

class LoadMoreRequest<T:ArrowParsable> {

    var limit = 12

    private var params = [String:Any]()
    private var offset = 0
    private var call: WSRequest!
    private var canLoadMore = true
    private var aCallback:((_ ts: [T]) -> [T])? = nil

    init(_ aCall: WSRequest) {
        call = aCall

    func resetOffset() {
        offset = 0
        canLoadMore = true

    func hasMoreItemsToload() -> Bool {
        return canLoadMore

    func fetchNext() -> Promise<[T]> {
        params = call.params
        params["limit"] = limit
        params["offset"] = offset
        call.params = params
        offset += limit
        return call.fetch()

    private func parseModels(_ json: JSON) -> [T] {
        let mapper = WSModelJSONParser<T>()
        let models = mapper.toModels(json)
        if models.count < limit {
            canLoadMore = false
        return models

As you can see, we have a strongly typed request.
The limit is adjustable.
It encapsulates a WSRequest.
It handles the offset logic and also wether or not there are more items to load.

And that’s all we need!

Now, this is how we build a LoadMoreRequest

func loadMoreUsersRequest() -> LoadMoreRequest<User> {
    return LoadMoreRequest(ws.getRequest("/users"))


And here is how we use it in our controllers :

class ViewController: UIViewController {

    // Get a request
    let request = api.loadMoreUsersRequest()

    override func viewDidLoad() {
        request.limit = 5 // Set a limit if needed

    func refresh() {
      // Resets the request, usually plugged with
      // the pull to refresh feature of a tableview

    func loadMore() {
      // Get the next round of users
      request.fetchNext().then { users in

    func shouldDisplayLoadMoreSpinner() -> Bool {
      // This asks the requests if there are more items to come
      // This is useful to know if we show the "load more" spinner
      return request.hasMoreItemsToload()

Here you go you now have a simple way to deal with load more requests in your App 🎉

Bonus – Simplifying restful routes usage

When working with a RESTFUL api, we can have fun and go a little further.

By introducing a RestResource protocol

public protocol RestResource {
    static func restName() -> String
    func restId() -> String

We can have a function that builds our REST URL

public func restURL<T:RestResource>(_ r:T) -> String {
    return "/(T.restName())/(r.restId())"

We conform our User Model to the protocol

extension User:RestResource {
    static func restName() -> String { return "users" }
    func restId() -> String { return "(identifier)" }

And we can implement a version of get that takes our a RestResource

public func get<T:ArrowParsable & RestResource>(_ restResource:T, params:[String:Any] = [String:Any]()) -> Promise<T> {               
    return get(restURL(restResource), params: params)



Can be written like :


Of course, the same logic can be applied to the all the other ws functions (post, put delete etc) ! 🎉



In your Cartfile

github "freshOS/ws"
  • Run carthage update
  • Drag and drop ws.framework from Carthage/Build/iOS to Linked Frameworks and Libraries (“General” settings tab)
  • Go to Project > Target > Build Phases + New run Script Phase

/usr/local/bin/carthage copy-frameworks

Add input files


This links ws and its dependencies.


Carthage is pretty useful since it takes care of pulling dependencies such as Arrow, then and Alamofire.
What’s cool is that it really is transparent. What I mean is that you could just use carthage on the side to pull and build dependencies and manually link frameworks to your Xcode project.

Without Carthage, I’d see 2 solutions :
1 – Copy paste all the source code : ws / then / Arrow / Alamofire which doesn’t sound like a lot of fun ;)
2 – Manually link the frameworks (ws + dependencies) by A grabbing .frameworks them on each repo, or B use Carthage to build them


target 'MyApp'
pod 'ws'

Swift Version

Swift 2 -> version 1.3.0
Swift 3 -> version 2.0.4
Swift 4 -> version 3.0.0
Swift 4.1 -> version 3.1.0
Swift 4.2 -> version 3.2.0


Like the project? Offer coffee or support us with a monthly donation and help us continue our activities :)


Become a sponsor and get your logo on our README on Github with a link to your site :)

Latest podspec

    "name": "TaleWs",
    "version": "5.0.4",
    "summary": "Elegant JSON WebService for Swift u2601ufe0f",
    "homepage": "",
    "license": {
        "type": "MIT",
        "file": "LICENSE"
    "authors": "arden",
    "source": {
        "git": "",
        "tag": "5.0.4"
    "social_media_url": "",
    "platforms": {
        "ios": "9.0"
    "source_files": "ws/*.{h,m,swift}",
    "frameworks": "Foundation",
    "dependencies": {
        "Arrow": [
            "~> 5.0.0"
        "thenPromise": [
            "~> 5.0.0"
        "Alamofire": [
            "~> 4.8.2"
    "description": "Elegant JSON WebService for Swift - Stop writing boilerplate JSON webservice code and focus on your awesome App instead",
    "module_name": "ws"

Pin It on Pinterest

Share This