<img src="https://github.com/ProxymanApp/atlantis/blob/0352184d411dbf0a9471967bfdd675cb850b0ccb/images/atlantis_logo.jpg" alt="Capture HTTP, HTTPS, Websocket from iOS with Atlantis by Proxyman" width="60%" height="auto"/>

Join our Discord Channel

Atlantis is developed by Proxyman Team

• Homepage: https://proxyman.com
• Twitter: https://twitter.com/proxyman_app
• Github: https://github.com/ProxymanApp

Features

• [x] ✅ Automatically intercept all YOUR HTTP/HTTPS Traffic with 1 click
• [x] ✅ No Proxy or trust any Certificates
• [x] ✅ Capture WS/WSS Traffic from URLSessionWebSocketTask
• [x] Capture gRPC traffic (Advanced)
• [x] Support iOS Physical Devices and Simulators, including iPhone, iPad, Apple Watch, Apple TV
• [x] NEW: Support Android with OkHttp, Retrofit, and Apollo
• [x] Review traffic log from macOS Proxyman app (Github)
• [x] Categorize the log by project and devices.
• [x] Ready for Production

⚠️ Note

• Atlantis is built for debugging purposes. Debugging tools (such as Map Local, Breakpoint, and Scripting) don't work.
• If you want to use debugging tools, please use normal Proxy.

Requirement

iOS

• macOS Proxyman app
• iOS 16.0+ / macOS 11+ / Mac Catalyst 13.0+ / tvOS 13.0+ / watchOS 10.0+
• Xcode 14+
• Swift 5.0+

Android

• See Atlantis Android for Android integration.

---

iOS Integration

👉 How to use

1. Install Atlantis framework

Swift Packages Manager (Recommended)

• Add https://github.com/ProxymanApp/atlantis to your project

2. Add Required settings to Info.plist

1. Open your iOS Project -> Open the Info.plist file and add the following keys and values:

<key>NSLocalNetworkUsageDescription</key>
<string>Atlantis would use Bonjour Service to discover Proxyman app from your local network. Atlantis uses it to transfer the data from your iOS app to Proxyman macOS for debugging purposes.</string>
<key>NSBonjourServices</key>
<array>
    <string>_Proxyman._tcp</string>
</array>

• Info.plist Example
• Reason: Atlantis uses Bonjour Service to transfer the data on your iPhone -> Proxyman macOS. It runs locally on your local network.

3. Add Atlantis to your project

Swift UI App

• Add Atlantis to your Main SwiftUI App

import SwiftUI

#if DEBUG
// 1. Import Atlantis
import Atlantis
#endif

@main
struct AtlantisSwiftUIAppApp: App {

    init() {
        // 2. Connect to your Macbook
        #if DEBUG
        Atlantis.start()
        
        // 3. (Optional)
        // If you have many Macbooks on the same WiFi Network, you can specify your Macbook's name
        // Find your Macbook's name by opening Proxyman App -> Certificate Menu -> Install Certificate for iOS -> With Atlantis ->
        // Click on "How to start Atlantis" -> Select "SwiftUI" Tab
        // Atlantis.start("Your's Macbook Pro")
        #endif
    }
}

UIKit App - Swift

• Open file AppDelegate.swift

#if DEBUG
import Atlantis
#endif

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

    #if DEBUG
        // 2. Connect to your Macbook
        Atlantis.start()

        // 3. (Optional)
        // If you have many Macbooks on the same WiFi Network, you can specify your Macbook's name
        // Find your Macbook's name by opening Proxyman App -> Certificate Menu -> Install Certificate for iOS -> With Atlantis ->
        // Click on "How to start Atlantis" -> Select "SwiftUI" Tab
        // Atlantis.start("Your's Macbook Pro")
    #endif

    return true
}

UIKit App - Objective-C

#import "Atlantis-Swift.h"

// Or import Atlantis as a module, you can use:
@import Atlantis;

// Add to the end of `application(_:didFinishLaunchingWithOptions:)` in AppDelegate.m file
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // Override point for customization after application launch.
    [Atlantis startWithHostName:nil shouldCaptureWebSocketTraffic:YES];
    return YES;
}

How to get your Mac name

• Useful when you have many Macbooks on the same WiFi Network, and you want to specify which Macbook to connect to.
• You can get the hostName: Open Proxyman macOS -> Certificate menu -> Install for iOS -> Atlantis -> How to Start Atlantis -> and copy the HostName

4. Start capture HTTPS with Atlantis and Proxyman app

1. Open Proxyman for macOS
2. Make sure your iOS devices/simulator and macOS Proxyman are in the same Wi-Fi network or connect your iOS Devices to your Mac by a USB cable
3. Start your iOS app via Xcode. Works with iOS Simulator or iOS Devices.
4. Proxyman now captures all HTTP/HTTPS, Websocket from your iOS app without any configuration.
5. Enjoy debugging ❤️

Capture Websocket Traffic

• By using Atlantis, Proxyman can capture Websocket from URLSessionWebsocketTask from iOS out of the box.
• If your app uses 3rd-party Websocket libraries (e.g. Starscream), Atlantis doesn't work because Starscream doesn't use URLSessionWebsocketTask under hood.
• Example app: https://github.com/NghiaTranUIT/WebsocketWithProxyman

SwiftUI Example App

Atlantis provides a simple iOS app that can demonstrate how to integrate and use Atlantis and Proxyman. Please follow the following steps:

1. Open Proxyman for macOS
2. Open iOS Project at ./Example/AtlantisSwiftUIApp.xcodeproj
3. Start the project with any iPhone/iPad Simulator or iPhone/iPad device
4. Tap on some buttons to see the HTTP/HTTPS Request/Response on Proxyman app

<details> <summary>Advanced Usage</summary>

By default, if your iOS app uses Apple's Networking classes (e.g. URLSession) or using popular Networking libraries (e.g. Alamofire and AFNetworking) to make an HTTP Request, Atlantis will work OUT OF THE BOX.

However, if your app doesn't use any one of them, Atlantis is not able to automatically capture the network traffic.

To resolve it, Atlantis offers certain functions to help you manually* add your Request and Response that will present on the Proxyman app as usual.

1. My app uses C++ Network library and doesn't use URLSession, NSURLSession, or any iOS Networking library

You can construct the Request and Response for Atlantis from the following func

    /// Handy func to manually add Atlantis' Request & Response, then sending to Proxyman for inspecting
    /// It's useful if your Request & Response are not URLRequest and URLResponse
    /// - Parameters:
    ///   - request: Atlantis' request model
    ///   - response: Atlantis' response model
    ///   - responseBody: The body data of the response
    public class func add(request: Request,
                          response: Response,
                          responseBody: Data?) {

• Example:

@IBAction func getManualBtnOnClick(_ sender: Any) {
    // Init Request and Response
    let header = Header(key: "X-Data", value: "Atlantis")
    let jsonType = Header(key: "Content-Type", value: "application/json")
    let jsonObj: [String: Any] = ["country": "Singapore"]
    let data = try! JSONSerialization.data(withJSONObject: jsonObj, options: [])
    let request = Request(url: "https://proxyman.com/get/data", method: "GET", headers: [header, jsonType], body: data)
    let response = Response(statusCode: 200, headers: [Header(key: "X-Response", value: "Internal Error server"), jsonType])
    let responseObj: [String: Any] = ["error_response": "Not FOund"]
    let responseData = try! JSONSerialization.data(withJSONObject: responseObj, options: [])
    
    // Add to Atlantis and show it on Proxyman app
    Atlantis.add(request: request, response: response, responseBody: responseData)
}

2. My app uses GRPC

You can construct the unary Request and Response from GRPC models via the interceptor pattern that is provided by grpc-swift and leverage this to get a complete log of your calls.

<details><summary>Here is an example for an AtlantisInterceptor</summary>

        import Atlantis
        import Foundation
        import GRPC
        import NIO
        import NIOHPACK
        import SwiftProtobuf

        extension HPACKHeaders {
            var atlantisHeaders: [Header] { map { Header(key: $0.name, value: $0.value) } }
        }

        public class AtlantisInterceptor<Request: Message, Response: Message>: ClientInterceptor<Request, Response> {
            private struct LogEntry {
                let id = UUID()
                var path: String = ""
                var started: Date?
                var request: LogRequest = .init()
                var response: LogResponse = .init()
            }

            private struct LogRequest {
                var metadata: [Header] = []
                var messages: [String] = []
                v