A modern iOS video downloader powered by a Node.js backend and yt-dlp.

Fetchy provides a seamless video downloading experience by offloading all heavy processing to a server, keeping the iOS app lightweight, fast, and battery-efficient.

Support iOS 15.6+

👉 日本語Readmeはこっち

flowchart LR

User((User))
App[iOS App - SwiftUI]
Share[Share Extension]
Backend[Public Node.js Backend - Railway,etc]
Queue[Job Processing System]
YTDLP[yt-dlp Engine]
Storage[Output Storage]

User --> App
User --> Share
Share --> App

App -->|Create Job| Backend
App -->|Poll Progress| Backend

Backend --> Queue
Queue --> YTDLP
YTDLP --> Storage
Storage --> Backend
Backend -->|Progress / Download URL| App

Most mobile downloader apps execute media processing directly on-device.

Fetchy experiments with a different design:

• Move CPU-heavy tasks to backend services
• Improve battery efficiency
• Keep UI highly responsive
• Allow backend improvements without forcing app updates

Fetchy currently uses a publicly accessible backend hosted on Railway.

This backend is intentionally open to:

• Observe real-world usage behavior
• Experiment with scaling video processing workloads
• Evaluate security and abuse prevention strategies

Planned future improvements include:

• Rate limiting
• Authentication
• Usage quotas

Fetchy is distributed as an IPA via GitHub Releases.

👉 https://github.com/nisesimadao/Fetchy/releases

You can install Fetchy using:

• AltStore
• SideStore
• TrollStore (if supported)

• Server-Side Processing: The backend handles yt-dlp execution, minimizing the iOS device's CPU and battery usage.
• Wide Site Compatibility: Supports downloading from hundreds of video sites thanks to yt-dlp.
• Real-Time Progress: The app's UI is updated in real-time by polling the backend for job status.
• Rich Download Options: Customize downloads with options for quality, format, metadata embedding, and more.
• Native SwiftUI Interface: A clean, modern, and responsive UI built entirely with SwiftUI.
• Share Extension: Start downloads directly from other apps (like Safari) via the iOS Share Sheet.
• Asynchronous by Design: The job-based architecture ensures the app remains responsive at all times.

Fetchy uses a client-server architecture to separate the user interface from the heavy lifting of video processing.

1. iOS App (Client): The user provides a video URL via the main app or the Share Extension.
2. API Request: The app sends a "start download" request to the Node.js backend.
3. Node.js API (Server): The server creates a unique job ID, immediately starts a yt-dlp download process in the background, and returns the job ID to the app.
4. Polling for Status: The iOS app periodically polls a status endpoint (/api/status/:jobId) to get real-time progress.
5. File Download: Once the server finishes downloading the video, the iOS app downloads the final file from a dedicated endpoint (/api/download/:jobId).

<!-- -->

+------------------+           +----------------------+           +----------------+
| iOS App (Client) | --(1)-->  | Node.js API (Server) | --(2)-->  | yt-dlp Process |
|                  | <-- JobID--|                      |           |                |
|                  |           |                      |           +----------------+
|   polls status   | --(3)-->  |  (manages job)       |
|                  | <--progress|                      |
|                  |           |                      |
| downloads file   | --(4)-->  |  (serves file)       |
+------------------+           +----------------------+

• Client (iOS): SwiftUI
• Server (Backend): Node.js, Express.js
• Core Dependency: yt-dlp

To run Fetchy, you need to set up both the backend server and the iOS client.

cd fetchy-api
npm install
npm start

For production use, you can deploy this backend to:

• Railway
• Render
• Heroku
• Any Node.js hosting provider

1. Open the project in Xcode:

open Fetchy.xcodeproj

1. Navigate to:

<!-- -->

Fetchy/Shared/Managers/APIClient.swift

1. Update backend URL:

private let baseURL = "https://your-backend-service-url.com"

1. Build & Run

Fetchy is provided as a technical architecture demonstration.

Users are responsible for complying with:

• Platform Terms of Service
• Copyright laws
• Local regulations

Pull Requests and Issues are welcome!

MIT License