# Where Does IPATool Store Downloaded IPA Files?

> Discover where IPATool stores downloaded IPA files. Learn about temporary locations and default output directories for your app bundles with majd/ipatool.

- Repository: [Majd/ipatool](https://github.com/majd/ipatool)
- Tags: how-to-guide
- Published: 2026-08-31

---

**IPATool writes downloaded IPA files to a temporary location in the system’s temp directory during the download process, then moves them to the current working directory by default (or a custom path specified via `--output-dir`) with a filename formatted as `<bundle_id>_<version>.ipa`.**

IPATool is an open-source command-line utility for downloading iOS app packages (IPA files) from the App Store. Understanding exactly where IPATool stores downloaded IPA files requires examining both the temporary download handling in the App Store client package and the file movement logic in the CLI command layer.

## Temporary Storage During the Download Process

In [`pkg/appstore/appstore_download.go`](https://github.com/majd/ipatool/blob/main/pkg/appstore/appstore_download.go), the **Download** method handles the actual HTTP request and initial file persistence. Rather than writing directly to the final destination, the implementation streams the response body into a temporary file created in the system's default temporary directory using `os.TempDir()`.

The code constructs the temporary file using `os.CreateTemp()` with a specific pattern:

```go
tmpDir := os.TempDir()
tempFile, err := os.CreateTemp(tmpDir, "ipatool-*.ipa")
if err != nil {
    return "", err
}
defer tempFile.Close()

// Write response body to the temporary file
if _, err := io.Copy(tempFile, resp.Body); err != nil {
    return "", err
}
return tempFile.Name(), nil

```

This approach ensures that incomplete downloads do not clutter the destination directory and provides a safe fallback if the network connection drops before the transfer completes.

## Final Destination and Default Behavior

Once the download completes, the CLI command in [`cmd/download.go`](https://github.com/majd/ipatool/blob/main/cmd/download.go) takes responsibility for relocating the temporary file to its permanent home. The **download** command constructs the final filename by replacing dots in the bundle ID with underscores and appending the version number.

The default behavior targets the **current working directory** when no `--output-dir` flag is provided:

```go
outputDir, _ := cmd.Flags().GetString("output-dir")
if outputDir == "" {
    cwd, err := os.Getwd()
    if err != nil {
        return err
    }
    outputDir = cwd
}

fileName := fmt.Sprintf("%s_%s.ipa", strings.ReplaceAll(bundleID, ".", "_"), version)
destPath := filepath.Join(outputDir, fileName)

```

The utility then moves the file using `util.MoveFile()`:

```go
if err := util.MoveFile(ipaPath, destPath); err != nil {
    return err
}
fmt.Printf("Saved IPA to %s\n", destPath)

```

## Customizing the Output Location

Users can override the default storage location by providing the `--output-dir` flag when invoking the download command. This flag accepts any valid directory path, and IPATool uses this value as the base directory for the final file placement.

The flag is defined in the command initialization:

```go
func init() {
    rootCmd.AddCommand(downloadCmd)
    downloadCmd.Flags().String("output-dir", "", "Directory to save the downloaded IPA (default: current directory)")
}

```

When provided, this directory takes precedence over the current working directory, though the filename generation logic remains identical.

## Summary

- **Temporary storage**: IPATool writes to `os.TempDir()` using `os.CreateTemp()` with the pattern `ipatool-*.ipa` during the download phase in [`pkg/appstore/appstore_download.go`](https://github.com/majd/ipatool/blob/main/pkg/appstore/appstore_download.go).
- **Default location**: Without the `--output-dir` flag, files move to the current working directory (`os.Getwd()`).
- **Filename format**: The output uses `<bundle_id>_<version>.ipa` where dots in the bundle ID convert to underscores.
- **Relocation method**: The `util.MoveFile()` function transfers the temporary file to its final destination after successful download completion.
- **Configuration**: Use the `--output-dir` flag to specify an alternative destination directory.

## Frequently Asked Questions

### Does IPATool keep temporary IPA files if the download fails?

No. The temporary file created with `os.CreateTemp()` in [`pkg/appstore/appstore_download.go`](https://github.com/majd/ipatool/blob/main/pkg/appstore/appstore_download.go) relies on deferred cleanup mechanisms. If the download fails or the process exits before `util.MoveFile()` executes in [`cmd/download.go`](https://github.com/majd/ipatool/blob/main/cmd/download.go), the temporary file remains in the system's temp directory until the OS routine cleanup removes it.

### Can I change the filename format of downloaded IPA files?

The current implementation hardcodes the filename format in [`cmd/download.go`](https://github.com/majd/ipatool/blob/main/cmd/download.go) using `fmt.Sprintf("%s_%s.ipa", ...)`. To use a custom naming scheme, you would need to modify the source code and recompile, or simply rename the file after IPATool completes the move operation.

### What happens if the destination directory does not exist?

The provided source code does not show explicit directory creation logic in [`cmd/download.go`](https://github.com/majd/ipatool/blob/main/cmd/download.go). IPATool attempts to join the output path and move the file via `util.MoveFile()`, which typically returns an error if the target directory does not exist. You should verify the directory exists before running the command to avoid move failures.

### Where does IPATool store downloaded IPA files on different operating systems?

On all platforms, IPATool uses Go's `os.TempDir()` for the initial download phase, which returns platform-specific paths (typically `%TEMP%` on Windows and `/tmp` on macOS/Linux). The final destination defaults to the current working directory regardless of the operating system, ensuring consistent cross-platform behavior.