Latest 2.0
License MIT
Platforms ios 8.0
Dependencies RxSwift, RxCocoa

This implementation of Interceptor in Swift is the same as the SwiftInterceptor one. It just used RxSwift instead of closure for the asynchronous part.


This Interceptor "concept" comes from the Interceptor implementation in the library Okhttp for Android (see Okhttp interceptor wiki).
This mechanism is very powerful when you want to modify/do some actions on an input object before and after the process it was given for.
See the interceptors as a middleware between the source of your input object and its final destination.

In this Swift implementation, two more things has been added:

  • Generic input.
  • Asynchronous process: the interceptor returns an Observable of Input object.

With Interceptors, you have:

  • clean and robust solution to handle:
    • network monitoring
    • adding parameters for all your requests in a same place
    • authentication (get/refresh a token), signed your request before sending it
    • retry failed request
    • and more.. ;)
  • clear distribution of roles:
    • each interceptor has a clear purpose
    • do only one thing on the input and output object
  • an easy way to improve test coverage with unit tests on each of your interceptors

To finish, as it’s generic, you can apply this mechanism in another context. Be creative ! :)



Cocoapods is a dependency manager for Cocoa projects. You can install it with the command:

$ gem install cocoapods

To add SwiftRxInterceptor to your project, write in your Podfile the following lines:

source ''
platform :ios, '8.0'

target '<Your Target Name>' do
    pod 'SwiftRxInterceptor'

Then run in a terminal the command:

$ pod install



First thing to do, it’s to create the Interceptor(s) you need. Remember, Interceptor is designed to be used to intercept the input object and/or the output object.
Group your Interceptors by concern and avoid duplicated ones

To do so, you just have to conform to the protocol Interceptor:

protocol Interceptor {
    associatedtype Input

    func intercept(chain: InterceptorChain<Input>) -> Observable<Input>


Intercept the input

struct MyInterceptor: Interceptor {
    func intercept(chain: InterceptorChain<URLRequest>) -> Observable<URLRequest> {
        // 1) Retrieve the input object (the request) and unwarpped the value
        guard let request = chain.input else {
            return chain.proceed()

        // 2) Do things with/on the request

        // 3) Continue the chaining with a new value
        return chain.proceed(object: request)

Interceptor chain

When you have your interceptors implemented, it’s finished !

To launch the process:

let disposeBag = DisposeBag()

// 1) I create an instance of interceptor chain. You can add many interceptor you want.
let chain = InterceptorChain(input: request)
    .add(interceptor: AnyInterceptor(base: MyInterceptor()))

// 2) Launch the process
    .subscribe { (event) in
        // 3) You get your data in the `.next` case 
    .disposed(by: disposeBag)

Additional informations

For more explanations about the interceptor mechanism, don’t hesitate to read the documentation in the okhttp wiki.
For non-RxSwift fans, you can have a look at the SwiftInterceptor implementation without any dependencies.

Latest podspec

    "name": "SwiftRxInterceptor",
    "version": "2.0",
    "summary": "Implementation of Okhttp Interceptor in Swift with RxSwift..",
    "homepage": "",
    "license": {
        "type": "MIT",
        "file": "LICENSE"
    "authors": "JPAlary",
    "platforms": {
        "ios": "8.0"
    "source": {
        "git": "",
        "tag": "2.0"
    "source_files": "SwiftRxInterceptor/Source/*.{swift}",
    "dependencies": {
        "RxSwift": [
            "~> 3.3"
        "RxCocoa": [
            "~> 3.3"
    "pushed_with_swift_version": "3.0"

Pin It on Pinterest

Share This