iosy

What Is iosy?

iosy is a standalone CLI tool that decompiles decrypted iOS IPA files to Swift projects for local app inspection. It generates Swift files for recovered types, call sites, and methods and places the Swift code, resources, and related app artifacts into a local project structure. The recovered project can be opened in the user’s editor to search for classes, methods, SDK calls, resources, and to review the app behavior at the source level.

The tool runs offline on the user’s machine, so the IPA remains on the workstation with no cloud decompilation or hosted processing. Its deterministic output likewise yields the same files when the same supported IPA is processed with the same iosy build. The program is beneficial for security checks, SDK audits, legacy app analysis, and authorized company or client initiatives.

What Is iosy Best For?

iosy stands out for Swift Code Recovery, which produces Swift files for the recovered types, methods, and call sites extracted from decrypted iOS IPA files. It puts the recovered Swift code into an organized local project with resources, directories, and other app artifacts. Users can then access this project in their preferred editor and explore restored classes, methods, SDK calls, and resources. This enables developers and security researchers to more easily inspect the code and structure of an iOS application during allowed analysis.

How Much Does iosy Cost?

Iosy pricing starts at $30 USD/month for the Individual plan. This plan includes swift file output, full swift project output, deterministic output, local CLI, and offline decompilation features. It also has further plans:

• Free Trial: $0
• Commercial: $300 USD/month

In addition to the base subscription costs, organizations should account for the following potential expenses:

• Implementation: $500–$2,500 (initial environment setup, licensing configuration, and enterprise deployment assistance)
• Training And Onboarding: $300–$1,500 (developer/security-researcher onboarding and workflow training)
• Integrations (API / SSO / Third-party systems): $1,000–$5,000 (SSO, identity management, CI/CD or security-tool integration where required)
• Customization And Configuration: $500–$3,000 (enterprise workflows, analysis configurations, and environment-specific setup)
• Premium Support: $1,000–$5,000/year (priority technical support and enterprise assistance)
• Infrastructure/Hosting: $0–$2,000/year (typically minimal because iosy is designed for deterministic offline/local processing; enterprise-managed environments may incur infrastructure costs)

Disclaimer: The pricing is subject to change.

iosy Integrations

The vendor has not specified any information about the software’s integrations.

How Does iosy Work?

Follow the steps outlined below to get started with the software:

• Download the iosy CLI for macOS, Windows, or Linux and extract the ZIP archive
• Sign in from the CLI using your OpenSyntaxx account to activate your plan
• Provide a decrypted IPA file that you are authorized to inspect
• Run iosy on the IPA to decompile the application locally
• Generate the recovered Swift project with types, methods, call sites, resources, and other app artifacts
• Open the generated project in your preferred editor to inspect the recovered code and project structure
• Review SDK usage, dependencies, integration points, and app-side calls within the recovered project

Who Is iosy For?

The software is designed to support a range of software development and security-focused teams, including:

• Software development companies
• Cybersecurity firms
• Mobile app development companies
• Software auditing firms
• Security research teams

iosy Use Cases

Based on our analysis of user feedback and iosy features, we have identified the following key scenarios where it is a good fit:

Security Teams Unable To Inspect iOS App Behavior From Readable Source

Security teams examining an iOS app may need to understand its behavior without working purely from symbols or assembly views. iosy turns an encrypted IPA into Swift files with recovered types, methods, and call locations for source-level analysis. Teams can launch the resulting project in their editor of choice and follow files and symbols while conducting a security evaluation. The local project structure also organizes Swift code, resources, and other app artifacts for review. This allows security teams to evaluate an iOS app’s behavior through a readable, locally generated project during their assessments.

Security Researchers Struggling To Trace Third-Party SDK Activity

Security researchers auditing an iOS application may need to identify how third-party SDKs are used and where they connect with the app. iosy provides searchable Swift output that allows reviewers to search for SDK calls within the recovered project. They can trace third-party SDK usage, integration points, and app-side calls across the generated files. This gives researchers a source-level view of these connections without requiring them to work only with the original binary. The recovered project can then be reviewed locally in the researcher’s preferred editor.

Analysis Teams Needing Consistent Output Across Repeated App Builds

Analysis teams comparing multiple runs may need consistent output to identify changes without dealing with unpredictable generated files. iosy offers deterministic runs, meaning the same supported input processed with the same iosy build generates the same output files. This consistency allows teams to compare recovered files across repeated analysis runs and identify variations in supported app builds. The resulting Swift project also provides a uniform structure for files, folders, and resources, making repeatable iOS app analysis easier without changes to the result structure between identical runs.

Development Teams Missing Source Code For Older iOS Applications

Development teams maintaining older iOS applications may need to work with an app when its original project files are no longer available. iosy can process an authorized, decrypted IPA and recover Swift files along with the application’s project structure, resources, and other app artifacts. Teams can open the recovered structure in their preferred editor to examine how the application is organized. This provides a workable representation of the application’s files and components for further development and analysis.

Is iosy Right For You?

If you are a security, software development, or research team that needs to analyze authorized iOS applications without access to their original source code, iosy may be a suitable option. Its focus is on recovering Swift source from decrypted IPA files for local analysis, making it relevant for security reviews, SDK audits, legacy application analysis, and other reverse-engineering work. It runs decompilation locally, keeping application files within the user's environment.

The software supports privacy-focused workflows by running decompilation locally on the user’s machine. OpenSyntaxx states that its web services do not receive IPA files, generated Swift files, app binaries, local project contents, or decompilation output. This keeps the application data being analyzed within the user’s local environment rather than sending it to the service.

Still not sure if iosy is right for you? Contact us at (661) 384-7070 and we will help you make the right choice.