Atlantis for iOS Traffic Capture with Proxyman

Why Atlantis exists for iOS debugging

Atlantis addresses a specific gap in iOS traffic inspection. A conventional proxy workflow can require configuring a proxy and trusting a certificate before an app's traffic appears in an inspection tool. Atlantis is designed for developers who need to observe traffic from an app under development without those network configuration steps. The README positions it as a debugging aid for capturing HTTP and HTTPS traffic, with WebSocket capture for URLSessionWebSocketTask. It also lists support for physical devices and simulators across several Apple platforms.

The intended users are iOS and macOS developers who already use the Proxyman application on macOS and need to see requests from their own app during development. Atlantis is not a general packet capture system and does not replace the full proxy workflow. It is most useful when the goal is traffic visibility for API analysis, request inspection, or development of a Proxyman review session. The README also states that gRPC capture is available at an advanced level, but it does not explain the setup beyond that note.

There is an important product boundary. Atlantis is built for debugging purposes, and the README explicitly says that debugging tools such as Map Local, Breakpoint, and Scripting do not work with it. If those features are central to the work, the documented alternative is a normal Proxy configuration. Atlantis focuses on bringing traffic into Proxyman, not on providing every interception and modification capability offered by the proxy path.

Atlantis architecture and traffic path

The repository is a Swift package with sources, tests, an Xcode project, configuration files, and an example app. The documented runtime path is app instrumentation to local discovery to Proxyman on macOS. Atlantis starts inside the application, then uses Bonjour service discovery to find Proxyman on the local network. The README describes this as a transfer from the iOS app to the Proxyman macOS app for debugging purposes.

The Swift integration imports Atlantis in a debug build and calls Atlantis.start(). An optional host name can be supplied when several Macbooks are present on the same Wi-Fi network. This matters because discovery is based on the local environment rather than a manually entered proxy endpoint. The macOS Proxyman application must be running, and the iOS device or simulator must either share the Mac's Wi-Fi network or be connected by USB according to the README's setup instructions.

Captured HTTP and HTTPS requests can then be reviewed in the macOS Proxyman app. Atlantis also documents capture of WebSocket messages from URLSessionWebSocketTask. The limitation is specific and useful: third-party WebSocket libraries such as Starscream are not supported because they do not use URLSessionWebSocketTask underneath. The README also lists support for capturing the body of async and await uploads and messages sent before a WebSocket connection is open in the current release notes. Those capabilities still depend on the request path and APIs used by the app.

Installing Atlantis and configuring the iOS project

The README recommends Swift Package Manager. Add the repository to the Xcode project, then add the local network usage description and Bonjour service declaration to Info.plist. The first block is the exact Info.plist content documented by the project. It explains why Atlantis needs local network access and registers the Proxyman discovery service.

<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>

After adding the package and keys, start Atlantis from the application entry point. The SwiftUI example below uses a debug-only import and calls Atlantis.start() during app initialization. The reader should expect Proxyman to discover the application once the app is launched under the documented network conditions.

import SwiftUI

#if DEBUG
import Atlantis
#endif

@main
struct AtlantisSwiftUIAppApp: App {
    init() {
        #if DEBUG
        Atlantis.start()
        #endif
    }
}

The README requires macOS Proxyman, iOS 16.0 or later for iOS, macOS 11 or later, Xcode 14 or later, and Swift 5.0 or later. It also lists Mac Catalyst 13.0 or later, tvOS 13.0 or later, and watchOS 10.0 or later. Atlantis is not presented as a standalone capture viewer. Proxyman on macOS remains the application used to review the traffic.

Adding Atlantis to SwiftUI and UIKit applications

A SwiftUI app can call Atlantis.start() from its App initializer. A UIKit Swift app can call the same method from application(_:didFinishLaunchingWithOptions:). The documented pattern places the import and call inside #if DEBUG, which keeps the instrumentation out of builds that do not need debugging traffic capture.

For UIKit Swift, use the following documented integration. The optional host-name form is useful when more than one Mac running Proxyman is visible on the same Wi-Fi network. The README says the host name can be found through Proxyman's certificate menu, then the Atlantis installation and startup instructions.

#if DEBUG
import Atlantis
#endif

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    #if DEBUG
    Atlantis.start()
    #endif

    return true
}

For an Objective-C UIKit application, the README shows importing the generated Swift header or the Atlantis module and calling the Objective-C wrapper. The call enables WebSocket capture with shouldCaptureWebSocketTraffic:YES.

#import "Atlantis-Swift.h"

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    [Atlantis startWithHostName:nil shouldCaptureWebSocketTraffic:YES];
    return YES;
}

These examples establish the first real use: launch the app with Atlantis enabled and review the resulting requests in Proxyman. They do not configure a proxy, install a certificate, or set up request modification.

WebSocket support and protocol coverage

WebSocket capture is narrow by design. The README states that Proxyman can capture WebSocket traffic from URLSessionWebSocketTask out of the box. Atlantis therefore has explicit coverage for Apple's URLSession-based WebSocket API, including messages sent before the connection is open according to the release information.

That does not mean every WebSocket library in an iOS project is supported. The README names Starscream as an example of a third-party library that does not work with Atlantis because it does not use URLSessionWebSocketTask underneath. If an app depends on another WebSocket implementation, the project gives no basis for assuming that its frames will appear in Proxyman. A developer must verify the library used by the target application before relying on WebSocket capture.

The same caution applies to other traffic types. Atlantis lists HTTP, HTTPS, WebSocket, and advanced gRPC capture, but the README does not document a complete matrix of supported networking libraries or every body type. Its release information also mentions support for async and await uploads and iOS loader behavior associated with HTTP/3 Early Data. These are release claims, not a guarantee that every request shape will be represented identically in the Proxyman log.

For teams evaluating Atlantis, protocol coverage should be checked against the actual app stack. A URLSession application is the clearest fit. A mixed application using URLSession for HTTP and a separate WebSocket library has only the first part clearly covered by the documented examples.

Limitations compared with a normal Proxyman proxy

The main limitation is functional, not a claim about traffic quality. Atlantis brings supported app traffic into Proxyman, but the README states that Map Local, Breakpoint, and Scripting do not work. A normal Proxy remains the documented choice when the workflow depends on changing responses, pausing execution, or scripting traffic.

Atlantis also depends on a connected development environment. The app must be able to reach the macOS Proxyman app through Bonjour discovery on the same local network, or the README says the iOS device can be connected to the Mac by USB. The Info.plist changes are therefore part of setup rather than optional documentation. If the Mac and device are isolated, Atlantis is the wrong tool for this documented workflow.

There is a release and platform boundary to account for. Atlantis 2.0.0 is dated 2026-10-14 and states support for iOS 26 and iOS 27 APIs. The README's minimum requirements remain iOS 16.0, macOS 11, Xcode 14, and Swift 5.0 for the iOS integration. Teams using another networking stack should first confirm that the traffic is within the supported URLSession-based path rather than assuming all network activity is captured.

A practical alternative is the normal Proxy workflow described in the README. It requires the app to use a proxy configuration and certificate trust, but it provides access to the debugging tools that Atlantis does not support. The choice depends on whether the immediate requirement is visibility or active traffic manipulation.

Maintenance, licensing, and upgrade considerations

The repository is not archived, and the last push was on 2026-10-14. The listed recent releases include Atlantis 2.0.0 on 2026-10-14, Atlantis 1.36.0 on 2026-05-28, and Atlantis 1.35.0 on 2026-05-01. Based on the last push date, the project has current repository activity, although maintenance status does not by itself guarantee compatibility with every app dependency or future operating system release.

The project uses the Apache-2.0 license. The repository contains a LICENSE file, and the README also displays an Apache-2.0 license badge. That identifies the declared licensing model, but it is not a substitute for reviewing the license text and application-specific compliance obligations.

Upgrading Atlantis may require checking the minimum platform requirements and the Swift Package Manager integration in the consuming Xcode project. The release information points to changes around new iOS APIs, URLSession loading behavior, upload bodies, and early WebSocket messages. These are areas where an application may need to confirm that its own networking code is still captured as expected after an upgrade. The repository includes Tests, but the README does not document a formal upgrade or rollback procedure for Atlantis itself.

Editorial conclusion

Adopt Atlantis when your iOS app needs HTTP or HTTPS inspection through Proxyman and can meet its macOS, Apple platform, and local network requirements. Do not adopt it as a replacement for a normal proxy when you need Map Local, Breakpoint, or Scripting, or when your WebSocket library does not use URLSessionWebSocketTask. Verify the supported platform version, Proxyman discovery path, WebSocket implementation, and whether traffic must remain limited to debug builds before integration.

Frequently asked questions

Official sources

1. License: Apache-2.0
2. Project website
3. ProxymanApp/atlantis on GitHub
4. README
5. Releases