Intercepting network traffic on Apple devices has traditionally meant jumping through hoops: setting up proxy configurations, trusting custom certificates, and wrestling with complex tooling. Atlantis cuts through this complexity by hooking directly into Apple’s URL Loading System at the URLProtocol layer, enabling interception of HTTP, HTTPS, WebSocket, and gRPC traffic without any proxy setup or certificate trust. This means you can inspect network calls from your iOS, macOS, tvOS, or watchOS app with a simple line of code wrapped in a debug flag.
how Atlantis intercepts network traffic across Apple platforms
Atlantis is a Swift framework created by the Proxyman team that intercepts all HTTP/HTTPS, WebSocket (via URLSessionWebSocketTask), and gRPC traffic from Apple platforms including iOS, macOS, tvOS, and watchOS. The key to its approach is hooking into Apple’s URL Loading System using the URLProtocol API — a native extension point where URL requests are handled and can be intercepted.
Unlike traditional proxy-based debugging tools that require manual proxy configuration on the device and trusting custom certificates, Atlantis operates entirely within the app process. It captures network traffic at the URLProtocol level, which means no device-wide proxy settings are necessary. This also avoids the common pitfalls around certificate trust and device configuration.
A standout architectural feature is its use of Bonjour (Apple’s zero-configuration networking protocol) to auto-discover the companion Proxyman desktop app on the same WiFi network or over USB. This discovery mechanism connects your app directly to Proxyman for live traffic inspection without manual setup.
Atlantis also supports gRPC traffic via a custom interceptor pattern compatible with grpc-swift, allowing inspection of gRPC calls which are increasingly common in modern mobile apps. Recently, the framework extended support to Android, targeting popular networking stacks like OkHttp, Retrofit, and Apollo.
what makes Atlantis technically interesting
The decision to intercept traffic at the URLProtocol layer is the defining technical strength here. URLProtocol is an official Apple API designed to let developers customize the loading of URL requests. By hooking into this, Atlantis avoids the traditional proxy approach that forces developers to configure device proxy settings and install custom certificates — steps that are often cumbersome and error-prone.
This zero-proxy architecture means the debugging flow is streamlined: the app itself handles traffic interception and routes captured data to the Proxyman desktop app using Bonjour for discovery and connection. The whole setup boils down to a one-liner in your code:
#if DEBUG
import Atlantis
#endif
@main
struct YourApp: App {
init() {
#if DEBUG
Atlantis.start()
#endif
}
}
This simplicity enhances developer experience (DX) dramatically, especially for teams frequently debugging network layers. Additionally, the framework supports specifying a particular Mac if multiple Proxyman instances are on the network.
On the gRPC front, Atlantis provides an interceptor pattern tailored for grpc-swift users. This shows attention to real-world networking stacks beyond plain HTTP, as gRPC is increasingly adopted for mobile communication.
The framework is also designed with modularity and platform coverage in mind, supporting all Apple platforms (iOS, macOS, tvOS, watchOS). It doesn’t try to be a full debugging toolbox — it focuses strictly on traffic interception and inspection, leaving features like request modification or mocking to other tools.
The tradeoff is that Atlantis relies on the app’s URL Loading System and thus can only intercept traffic routed through URLSession or grpc-swift clients using their standard mechanisms. Custom networking stacks not built on these foundations may require additional manual integration.
how to get started with Atlantis
1. Install Atlantis framework
The recommended way is via Swift Package Manager:
- Add
https://github.com/ProxymanApp/atlantisto your project’s package dependencies.
2. Configure your app’s Info.plist
Add the following keys to enable Bonjour service discovery, which Atlantis uses to communicate with the Proxyman desktop app:
<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>
3. Add Atlantis to your app code
For SwiftUI apps, include the following in your main app file:
import SwiftUI
#if DEBUG
import Atlantis
#endif
@main
struct AtlantisSwiftUIAppApp: App {
init() {
#if DEBUG
Atlantis.start()
// Optional: Specify your Mac's name if multiple Proxyman instances are on the network
// Atlantis.start("Your MacBook Pro")
#endif
}
}
For UIKit apps, in your AppDelegate.swift:
#if DEBUG
import Atlantis
#endif
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
#if DEBUG
Atlantis.start()
// Optional: Specify your Mac's name if multiple Proxyman instances are on the network
// Atlantis.start("Your MacBook Pro")
#endif
return true
}
This minimal setup means in debug builds your app will automatically route its network traffic to Proxyman for inspection.
verdict: who should consider Atlantis
Atlantis is a solid choice if you’re developing apps on Apple platforms and want to inspect HTTP/HTTPS, WebSocket, or gRPC traffic without the hassle of proxy configurations and certificate management. Its zero-proxy, zero-trust setup significantly improves network debugging DX, especially for teams shipping iOS or macOS apps.
It’s particularly relevant if your app uses Apple’s URL Loading System or grpc-swift for networking. However, if your networking stack is heavily customized or uses non-standard protocols, Atlantis might require additional integration effort or might not cover all traffic.
By focusing strictly on traffic interception and inspection, Atlantis keeps its codebase clean and purpose-driven. It’s not a full debugging suite with request manipulation or mocking features, so you’ll want to complement it with other tools if you need those capabilities.
Overall, Atlantis brings a pragmatic and well-engineered approach to a persistent pain point in Apple app development. The code is surprisingly straightforward under the hood for what it achieves, and the use of Bonjour for discovery is a neat touch that minimizes setup friction. Worth understanding and trying if you debug network traffic on Apple devices regularly.
→ GitHub Repo: ProxymanApp/atlantis ⭐ 1,530 · Swift