# Cam4 Downloader Browser Extension (`serpxxx/cam4-downloader`) Actor

Cam4 Downloader listing and downloader workflow.

- **URL**: https://apify.com/serpxxx/cam4-downloader.md
- **Developed by:** [SERP X](https://apify.com/serpxxx) (community)
- **Categories:** Videos, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Cam4 Downloader Browser Extension

> Record Cam4 live streams and download recorded videos as MP4 files for offline viewing.

Cam4 Downloader is a browser extension built for people who want a simple way to save Cam4 videos without messing with stream URLs, scripts, or desktop tools. It works on live broadcasts and recorded videos, detects available qualities automatically, and saves the final file as MP4 so it plays anywhere.

- Record Cam4 live streams before they end
- Download recorded videos from performer and profile pages
- Pick from available resolutions up to 1080p and 60fps where supported
- Save videos as standard MP4 files for offline playback
- Use player controls, popup controls, or right-click actions
### Table of Contents

- [Why Cam4 Downloader](#why-cam4-downloader)
- [Features](#features)
- [How It Works](#how-it-works)
- [Step-by-Step Tutorial: How to Download Videos from Cam4](#step-by-step-tutorial-how-to-download-videos-from-cam4)
- [Supported Formats](#supported-formats)
- [Who It's For](#who-its-for)
- [Common Use Cases](#common-use-cases)
- [Troubleshooting](#troubleshooting)
- [Trial & Access](#trial--access)
- [Installation Instructions](#installation-instructions)
- [FAQ](#faq)
- [Notes](#notes)
- [About Cam4](#about-cam4)

### Why Cam4 Downloader

Cam4 is built for streaming, not for saving. Live broadcasts disappear when they end, and recorded videos are usually delivered through streaming methods that generic download extensions do not handle well. That leaves most users stuck with unreliable workarounds or tools that only work part of the time.

Cam4 Downloader is designed specifically for that gap. Instead of asking you to inspect network requests or copy playlist URLs, it adds a direct browser-based workflow for capturing live sessions and downloading recorded content in a file format you can actually use.

### Features

- Live stream recording for active Cam4 broadcasts
- Recorded video downloads from supported Cam4 pages
- Automatic stream detection after playback starts
- Quality picker for available resolutions
- Support for high-quality sources up to 1080p and 60fps where available
- In-page controls for faster access
- Popup controls for download management
- Right-click context menu support
- MP4 output for broad device compatibility
- Dedicated download folder organization
- VR stream support where available
- Works on Chrome, Edge, Brave, Opera, Firefox, Whale, and Yandex

### How It Works

1. Install the extension from the latest release.
2. Open Cam4 and go to a live room or recorded video page.
3. Start playback so the extension can detect the stream.
4. Open the popup or use the on-page download controls.
5. Select the quality you want if multiple options are available.
6. Start recording for live video or begin downloading for recorded content.
7. Save the finished MP4 file to your computer.

### Step-by-Step Tutorial: How to Download Videos from Cam4

1. Open the latest release and install Cam4 Downloader in your browser.
2. Visit Cam4 and sign in if the page you want requires account access.
3. Open the live stream or recorded video you want to save.
4. Let the player load fully and press play.
5. Click the Cam4 Downloader button in the browser toolbar or on the page.
6. Choose the quality option you want from the list shown by the extension.
7. If it is a live stream, click Start and let the recording run until you are done.
8. If it is a recorded video, click Download and wait for the transfer to finish.
9. Open the saved MP4 from your Downloads folder.

### Supported Formats

- Input: Cam4 live streams
- Input: Cam4 recorded videos
- Output: MP4

Saved files are produced in standard MP4 format so they work in normal media players, phone transfers, offline archives, and most editing software.

### Who It's For

- Cam4 viewers who want to keep live broadcasts before they disappear
- Users with access to recorded videos who want offline playback
- People building a personal archive of content they are allowed to save
- Non-technical users who want a browser extension instead of a desktop recorder
- Users who want a cleaner workflow than manual stream extraction

### Common Use Cases

- Record a live Cam4 performance for later viewing
- Save recorded videos from a performer page
- Keep access to purchased or member-only content you are allowed to download
- Download the best available quality for offline playback
- Save VR-supported content for later viewing on compatible devices

### Troubleshooting

**The extension is not detecting the video**  
Press play first and wait a few seconds. Stream detection usually starts after playback begins.

**The download button does not appear on the page**  
Open the extension popup manually. Some supported pages work better from the popup than from in-page controls.

**No quality options are showing**  
Some streams only expose one playable source. In that case, the extension will use the available stream automatically.

**The live recording stopped too early**  
Make sure the stream stayed active for the full session and that your internet connection did not drop during capture.

**The page requires login or membership access**  
The extension only works on content you can already access in your browser session.

### Trial & Access

- Includes **3 free downloads** so you can test the workflow first
- Email sign-in uses secure one-time password verification
- No credit card required for the trial
- Unlimited downloads are available with a paid license

Start here: [https://serp.ly/cam4-video-downloader](https://serp.ly/cam4-video-downloader)

### Installation Instructions

1. Open the latest release page:
   [https://github.com/serpxxx/cam4-downloader/releases/latest](https://github.com/serpxxx/cam4-downloader/releases/latest)
2. Download the build for your browser.
3. Install the extension.
4. Open Cam4 and go to a live stream or recorded video page.
5. Use the extension controls to start recording or downloading.

### FAQ

**Can I record Cam4 live streams?**  
Yes. Live broadcasts can be recorded while they are actively streaming.

**Can I download recorded Cam4 videos too?**  
Yes. The extension supports recorded videos on supported Cam4 pages.

**What file format do downloads use?**  
Videos are saved as MP4 files.

**What quality options are available?**  
That depends on the source stream. The extension lists whatever qualities Cam4 makes available on that page.

**Does this work with VR content?**  
Yes, where compatible VR stream data is available.

**Where are videos saved?**  
They are saved to your browser's default Downloads location, typically inside a CAM4-related subfolder.

**Do I need extra software?**  
No. The workflow runs through the browser extension.

### License

This repository is distributed under the proprietary SERP Apps license in the [LICENSE](https://github.com/serpxxx/cam4-downloader/blob/main/LICENSE) file. Review that file before copying, modifying, or redistributing any part of this project.

### Notes

- An active internet connection is required
- Live recording only works while the broadcast is actually live
- Some videos may require account access, membership, or payment
- Source quality depends on the stream provided by Cam4
- Only download content you own or have permission to save

### About Cam4

Cam4 is a live cam platform centered on real-time broadcasts, performer rooms, and recorded video content. It is optimized for online streaming, which makes offline saving awkward for normal users. Cam4 Downloader simplifies that process for people who want a direct browser-based way to keep accessible content in MP4 format.

# Actor input Schema



## Actor input object example

```json
{}
````

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("serpxxx/cam4-downloader").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("serpxxx/cam4-downloader").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call serpxxx/cam4-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=serpxxx/cam4-downloader",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cam4 Downloader Browser Extension",
        "description": "Cam4 Downloader listing and downloader workflow.",
        "version": "0.0",
        "x-build-id": "ZgGBB6zHfj1UqTg2g"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/serpxxx~cam4-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-serpxxx-cam4-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/serpxxx~cam4-downloader/runs": {
            "post": {
                "operationId": "runs-sync-serpxxx-cam4-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/serpxxx~cam4-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-serpxxx-cam4-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {}
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
