---
title: How to Build a Cordova iOS App Without a Mac
description: Build and sign a Cordova iOS app in the cloud without a Mac. Use Capawesome Cloud Native Builds to produce a signed .ipa from Windows or Linux in minutes.
date:
created: 2026-06-11
updated: 2026-07-17
authors:
- robingenz
categories:
- Cloud
- Cordova
- Guides
faq: true
---
# How to Build a Cordova iOS App Without a Mac
You can build a Cordova iOS app without owning a Mac by running the build on a hosted macOS machine in the cloud. The catch every Cordova developer on Windows or Linux runs into is that `cordova build ios` needs Xcode, and Xcode only runs on macOS. The good news is that the Mac can live in a data center instead of on your desk.
This is a hands-on walkthrough. By the end you'll have connected a Cordova project to a cloud build service, uploaded your signing certificate, and pulled down a signed `.ipa`, all without a Mac in the room.
## Key Takeaways
- Building a Cordova iOS app requires macOS, because Apple's toolchain (Xcode, `xcodebuild`, `codesign`) is macOS-only.
- You don't have to own a Mac. [Capawesome Cloud](https://capawesome.io){:target="_blank"} builds Cordova apps on hosted Apple Silicon (M4) macOS instances and works from Windows, Linux, or macOS.
- To produce a signed build, you upload an iOS distribution certificate (a `.p12` with its private key) and a matching provisioning profile once.
- A single command, `apps:builds:create --platform ios`, returns a signed `.ipa`. iOS build types cover simulator, development, ad-hoc, app-store, and enterprise.
- There's no build YAML to write. Cordova projects are detected automatically, and signing credentials are injected at build time.
## Why does building a Cordova iOS app need a Mac?
Apple's iOS build toolchain runs only on macOS. Xcode, `xcodebuild`, and `codesign` have no Linux or Windows equivalent, and there's no supported way to produce a real `.ipa` outside an Apple-controlled environment. When you run `cordova build ios`, Cordova generates an Xcode project and then hands off to that toolchain, so the final packaging and signing step always happens on a Mac.
That leaves three ways to get one: buy a Mac, rent a remote Mac by the hour, or use a mobile CI/CD service that gives you a managed macOS build on demand. Each trades cost against how much of the macOS box you have to manage yourself. We compared all three in [How to Build and Deploy iOS Apps Without Owning a Mac](./how-to-build-and-deploy-ios-apps-without-a-mac.md), so this post skips the comparison and goes straight to the managed-build approach for a Cordova project.
## What you need before you start
Before triggering a cloud build, get three things in order. You'll need a Cordova app in a Git repository, an [Apple Developer Program](https://developer.apple.com/programs/){:target="_blank"} membership, and the signing assets that Apple requires for any installable iOS build.
For a signed build, that means an iOS distribution certificate exported as a `.p12` file that includes its private key, the password you set when exporting it, and a provisioning profile whose bundle identifier matches your app. If wrangling certificates in Keychain Access isn't appealing, the [iOS Certificate Generator](https://capawesome.io/tools/ios-certificate-generator/){:target="_blank"} creates a valid `.p12` for you. A simulator build skips signing entirely, which is useful for a first smoke test.
## Build a Cordova iOS app without a Mac, step by step
The whole flow is four commands and one credential upload. Here's each step.
### Step 1: Create the app in Capawesome Cloud
Start by creating an app and telling the Cloud it's a Cordova project. The CLI prompts for the organization and name, then prints the new app ID:
```bash
npx @capawesome/cli apps:create --type cordova
```
The `--type cordova` flag is what marks the project as Cordova rather than Capacitor or native. Keep the app ID handy for the commands below.
### Step 2: Connect your Git repository
Cloud builds run from a Git reference, so the next step is linking your repository. Run the link command from inside your project and it detects the provider, owner, and repository name from your `origin` remote:
```bash
npx @capawesome/cli apps:link --app-id
```
Capawesome Cloud connects to GitHub, GitLab, Bitbucket, Azure DevOps, Gitea, and any other Git server over HTTP/S. You can also link the repository from the [Console](https://console.cloud.capawesome.io){:target="_blank"} if you'd rather authorize the provider through a web flow.
### Step 3: Upload your iOS signing certificate
A signed iOS build needs your distribution certificate and provisioning profile available to the build machine. Upload them once on the [Signing Certificates](https://console.cloud.capawesome.io/apps/_/certificates){:target="_blank"} page: provide the `.p12` file, its password, and the matching `.mobileprovision` profile. They're stored encrypted and injected into the build automatically from then on.
The [iOS certificates documentation](../../cloud/native-builds/certificates/ios.md) covers the details, including apps with extensions that need a separate profile per target.
### Step 4: Trigger a signed build
With the repository linked and the certificate uploaded, one command builds and signs the app. This produces an App Store build from the `main` branch and downloads the `.ipa` when it finishes:
```bash
npx @capawesome/cli apps:builds:create \
--platform ios \
--type app-store \
--certificate "My Distribution Certificate" \
--git-ref main \
--ipa
```
Swap `--type` for `development` or `ad-hoc` depending on where the build is headed, and pass the name of the certificate you uploaded in step 3 to `--certificate`. If you want to test a local change without committing first, replace `--git-ref` with `--path .` to upload your working copy instead.
### Step 5: Get the signed .ipa
The `--ipa` flag in the previous command downloads the artifact to your machine as soon as the build completes. If you triggered the build without it, you can pull the artifact from a finished build directly:
```bash
npx @capawesome/cli apps:builds:download --ipa ./app.ipa
```
From the Console, the build's detail page has a **Download** button for the `.ipa` and an **Install** option that shows a QR code for side-loading onto a registered device.
## What about config.xml and the build environment?
There's no build configuration file to write. Capawesome Cloud detects a standard Cordova project from its `config.xml` and `platforms` layout, installs dependencies, and runs the build. Native Builds works with Capacitor, Cordova, and plain native projects without per-framework setup.
Two things are worth knowing. If your Cordova app lives in a subdirectory of a monorepo, add a `capawesome.config.json` at the repository root with a `baseDir` pointing at it, and optionally a `webBuildCommand` for your web build. And if you need a specific Xcode version, the build runs on a selectable macOS stack (Sequoia or Tahoe), each with a recent Xcode preinstalled, chosen with the `--stack` flag. The full set of options lives in the [Native Builds configuration](../../cloud/native-builds/configuration.md) docs.
Android works the same way. Run the build with `--platform android` and provide an [Android keystore](https://capawesome.io/tools/android-keystore-generator/) instead of a `.p12`, and you get a signed `.aab` or `.apk` from the same pipeline.
## Get Started
[Building a Cordova iOS app without a Mac](https://capawesome.io/solutions/build-without-mac/){:target="_blank"} comes down to creating an app, linking your repo, uploading a certificate, and running one build command. The [Native Builds setup guide](../../cloud/native-builds/setup.md) walks through the full pipeline, and once you have a signed App Store build, [App Store Publishing](../../cloud/app-store-publishing/index.md) can push it straight to TestFlight.
For the bigger picture beyond iOS builds, this short video tours Cordova support in Capawesome Cloud — native builds, store publishing, and live updates together.
[Try Capawesome Cloud Free](https://capawesome.io){ .md-button .md-button--primary }
## FAQ
### Can I test my build before paying for an Apple Developer membership?
Yes, with a simulator build. Running `apps:builds:create --platform ios --type simulator` skips signing entirely, so you can verify your Cordova project builds cleanly on the cloud macOS environment before you've bought a certificate or even joined the Apple Developer Program. Signing only becomes necessary once you need a build that installs on a real device or ships to TestFlight.
### What if my Cordova project isn't at the root of the repository?
Add a `capawesome.config.json` file at the repository root with a `baseDir` field pointing at the Cordova project's actual location, and optionally a `webBuildCommand` if your web assets need a build step first — see the [Monorepo](../../cloud/native-builds/monorepo.md) documentation for the full configuration. Without this, Capawesome Cloud expects to find `config.xml` at the repo root.
### Does the cloud build replace needing a Mac entirely, even for debugging?
Not for interactive debugging. A cloud build hands off the compile-and-sign step, but running the app in the iOS Simulator with breakpoints and live inspection still needs a local macOS environment. For that specific case, a borrowed or rented Mac still has a role — the cloud build is for producing installable, signed artifacts, not for step-through debugging.
### Can the same setup build my Android version too?
Yes. Swap `--platform ios` for `--platform android` and provide an Android keystore instead of a `.p12` certificate — the same app, repository link, and CLI command produce a signed `.aab` or `.apk` through the identical pipeline.
### What Xcode version does the cloud build use?
Whichever comes with the macOS stack you select via `--stack` — currently Sequoia or Tahoe, each preinstalled with a recent Xcode version. If you don't specify a stack, the build uses the default one.
## Related Posts
- [Announcing Cordova Support in Capawesome Cloud](./announcing-cordova-support-in-capawesome-cloud.md)
- [The Best CI/CD Platforms for Cordova Apps in 2026](./comparing-ci-cd-platforms-for-cordova-apps.md)
- [Cordova Hot Code Push Alternative for OTA Updates](./cordova-hot-code-push-alternative.md)
- [Cordova Live Updates: A Complete Guide to OTA Updates](./cordova-live-updates-guide.md)
## Conclusion
A Cordova iOS build needs macOS, but it no longer needs *your* macOS. Hand the Xcode and signing work to a hosted Mac, keep writing your app on Windows or Linux, and let a single CLI command return the signed `.ipa`. The one thing a cloud build can't do is replace a local simulator for interactive debugging, so a borrowed or rented Mac still helps there.
If you're weighing the wider picture of where Cordova CI/CD is heading now that App Center is gone and Appflow is winding down, read [The Modern CI/CD Solution for Cordova Apps in 2026](./ci-cd-for-cordova-apps.md).
Stuck on a certificate or a build error? Ask in the [Capawesome Discord server](https://discord.gg/VCXxSVjefW){:target="_blank"}, and subscribe to the [Capawesome newsletter](https://capawesome.io/newsletter/){:target="_blank"} to follow what's next for Cordova on Capawesome Cloud.