# How Often Does the ReClip Frontend Poll for Download Status?

> Discover how often the ReClip frontend polls for download status. Learn about the setInterval timer and its 1-second polling interval in the pollCard function.

- Repository: [Avery Gan/reclip](https://github.com/averygan/reclip)
- Tags: internals
- Published: 2026-09-05

---

**The ReClip frontend polls the server for download status exactly once every second (1000 milliseconds) using a JavaScript `setInterval` timer defined in the `pollCard` function.**

ReClip is an open-source YouTube downloader that provides real-time download progress updates through its web interface. When a user initiates a video download, the frontend begins actively monitoring the job status through HTTP polling to provide immediate visual feedback. Understanding this polling frequency helps developers optimize network usage and diagnose latency issues within the `averygan/reclip` codebase.

## The 1-Second Polling Mechanism

The polling interval is hardcoded in [`templates/index.html`](https://github.com/averygan/reclip/blob/main/templates/index.html) at line 555, where the `pollCard` function establishes a recurring timer to check download progress. According to the ReClip source code, this interval is set to **1000 milliseconds** (1 second), balancing real-time updates with server load.

```javascript
// Located in templates/index.html, line 555
const iv = setInterval(async () => {
  const res = await fetch(`/api/status/${c.jobId}`);
  const data = await res.json();
  
  // Status handling logic omitted for brevity
}, 1000);  // 1000ms = 1 second polling interval

```

## How Status Polling Works in ReClip

The polling lifecycle involves three distinct phases: initiation, execution, and termination.

### Initiating the Download with `dlCard`

When a user starts a download, the `dlCard` function handles the initial request and stores the returned `jobId`. It then immediately invokes `pollCard` to begin monitoring the job's progress on the frontend.

### The `pollCard` Polling Loop

Inside `pollCard`, the code creates a `setInterval` timer assigned to the variable `iv`. Every 1000 milliseconds, the interval triggers an asynchronous `fetch` request to the `/api/status/<jobId>` endpoint. The response data updates the UI elements to reflect current download progress.

```javascript
// Simplified flow from templates/index.html
await dlCard(index);   // Stores jobId and triggers polling

// Inside pollCard function:
const iv = setInterval(async () => {
  const res = await fetch(`/api/status/${c.jobId}`);
  const data = await res.json();

  if (data.status === 'done') {
    clearInterval(iv);        // Stop polling on completion
    // Handle completed download UI updates
  } else if (data.status === 'error') {
    clearInterval(iv);        // Stop polling on failure
    // Handle error state UI updates
  }
}, 1000);  // Fixed 1-second interval

```

### Termination Conditions

The polling loop automatically terminates when the backend returns a terminal status. Specifically, the frontend checks for two conditions:

- **`status === 'done'`**: The download completed successfully
- **`status === 'error'`**: The download encountered a failure

Upon detecting either state, the code executes `clearInterval(iv)` to stop further network requests and prevent memory leaks or unnecessary server load.

## Backend Support in [`app.py`](https://github.com/averygan/reclip/blob/main/app.py)

The Flask backend in [`app.py`](https://github.com/averygan/reclip/blob/main/app.py) exposes the `/api/status/<job_id>` endpoint that the frontend polls every second. This endpoint returns a JSON object containing the current job state, which the `pollCard` function parses to determine whether to continue polling or clear the interval.

## Summary

- **Polling Frequency**: The ReClip frontend polls for download status every **1000 milliseconds** (1 second).
- **Core Function**: `pollCard` in [`templates/index.html`](https://github.com/averygan/reclip/blob/main/templates/index.html) (line 555) controls the polling mechanism.
- **API Endpoint**: Frontend requests hit `/api/status/<jobId>` to retrieve current status.
- **Auto-Stop Logic**: Polling automatically stops when `status` equals `'done'` or `'error'` via `clearInterval`.

## Frequently Asked Questions

### What is the exact polling interval used by ReClip?

The ReClip frontend uses a fixed **1000-millisecond (1-second)** polling interval. This value is hardcoded as the second argument to `setInterval` in the `pollCard` function within [`templates/index.html`](https://github.com/averygan/reclip/blob/main/templates/index.html).

### Which JavaScript function controls the download status polling?

The **`pollCard`** function controls all download status polling. It is invoked by `dlCard` after a download job is initiated, and it manages the `setInterval` timer that queries the backend every second.

### How does ReClip stop polling when a download completes?

ReClip stops polling by calling **`clearInterval(iv)`** when the backend response contains `status: 'done'` or `status: 'error'`. This prevents unnecessary network requests and potential memory leaks once the job reaches a terminal state.

### Where is the polling logic located in the source code?

The polling logic resides in **[`templates/index.html`](https://github.com/averygan/reclip/blob/main/templates/index.html)** at line 555, specifically within the `pollCard` function. The corresponding backend endpoint that handles these requests is defined in **[`app.py`](https://github.com/averygan/reclip/blob/main/app.py)**.