# Borwap Video Downloader | How to Download Borwap Videos (`serpdownloaders/borwap-video-downloader-how-to-download-borwap-videos`) Actor

- **URL**: https://apify.com/serpdownloaders/borwap-video-downloader-how-to-download-borwap-videos.md
- **Developed by:** [SERP Downloaders](https://apify.com/serpdownloaders) (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

## Borwap Video Downloader | How to Download Borwap Videos

> A conservative browser-based downloader candidate for legacy-style Borwap pages, designed to detect and save media from Borwap's mixed http/https surface.

### Get it Here

Get it here: https://serp.ly/borwap-downloader

![Borwap Downloader](https://apps.serp.co/media/optimized-products/borwap-downloader-homescreen-adult-8f80c8bb59.webp)

This extension provides a generic static-media baseline for Borwap URLs, focusing on the site's older `/en/download/...?...` page shape and the `xxx_new.jsp` handoff route. It uses standard title, video, and thumbnail selectors to offer a straightforward way to save media from Borwap pages.

- Covers Borwap's mixed http and https protocol footprint
- Supports wildcard subdomains across borwap.com
- Targets legacy-style download page patterns
- Uses a generic static-media approach rather than a custom extractor
- Honest about its candidate-stage status with clear limitations
### Table of Contents

- [Why Borwap Downloader](#why-borwap-downloader)
- [Features](#features)
- [How It Works](#how-it-works)
- [Step-by-Step Tutorial: How to Download Videos from Borwap](#step-by-step-tutorial-how-to-download-videos-from-borwap)
- [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)
- [License](#license)
- [About Borwap](#about-borwap)

### Why Borwap Downloader

Borwap is an older WAP-style platform that serves content across both http and https protocols, with wildcard subdomains and unusual URL patterns like `/en/download/...?...` and `xxx_new.jsp`. This mixed surface makes it difficult for generic downloaders to handle consistently, and most modern video tools simply ignore legacy-style pages like Borwap.

Borwap Downloader fills that gap by providing a conservative, browser-based candidate that focuses specifically on Borwap's unique URL footprint. Instead of overpromising with custom extraction features that aren't confirmed, this extension honestly documents its generic static-media baseline and candidate-stage status. It uses standard selectors to detect title, video, and thumbnail signals, giving users a straightforward way to attempt media downloads from Borwap pages.

### Features

- Borwap-specific URL coverage across borwap.com and wildcard subdomains
- Mixed http and https protocol scope called out directly
- Generic static-media baseline with standard title, video, and thumbnail selectors
- Clear focus on `/en/download/...?...` and `/en/xxx_new.jsp` page patterns
- Candidate-stage disclosure with honest QA status
- No invented workflow claims for unconfirmed features
- Works within the browser without external software
- Free trial available to test the workflow

### How It Works

1. Install the extension from the latest release.
2. Open Borwap and go to a supported video page.
3. Start playback so the extension can detect the media.
4. Open the popup or use the on-page controls.
5. Choose the quality option you want.
6. Start the download and wait for the MP4 export to finish.
7. Save the final file locally.

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

1. Open your browser and navigate to a Borwap page containing video content.
2. Look for pages following the `/en/download/...?...` pattern or the `xxx_new.jsp` handoff route.
3. Let the page load fully so the extension can detect any media elements.
4. Click the Borwap Downloader icon in your browser toolbar to open the popup.
5. The extension will scan the page for available media sources.
6. Select your preferred quality or format option from the list.
7. Click the download button to start saving the file.
8. Choose a save location on your device and wait for the download to complete.

### Supported Formats

- Input: Standard video elements and source tags detected on Borwap pages, including `<video>` tags with `src` attributes, `<source>` elements, and Open Graph video meta tags
- Output: MP4

Saved files use MP4 so they are easier to replay on standard media players, move between devices, or archive locally.

### Who It's For

- Users trying to save media from Borwap pages for offline viewing
- People working with legacy WAP-style video platforms
- Product and marketing teams needing honest copy for a target-verified candidate
- Users who prefer a browser-based downloader over standalone software

### Common Use Cases

- Saving Borwap videos for offline playback without an internet connection
- Archiving media from Borwap's older download page patterns
- Testing Borwap support with a generic static-media baseline
- Evaluating the candidate before committing to a custom extractor
- Documenting Borwap's mixed protocol and subdomain coverage

### Troubleshooting

**The extension doesn't detect any media on the page**
Make sure you are on a supported Borwap page with the correct URL pattern. The current sample quality is weak, and not all Borwap pages may work reliably.

**The download starts but fails to complete**
Check your internet connection and try refreshing the page. Some Borwap URLs may require the media to start playing before detection works.

**I see an error about unsupported page**
The extension is a candidate-stage tool and may not work on every Borwap page. Try a different Borwap URL, especially one following the `/en/download/...?...` pattern.

**The popup shows no quality options**
This could mean the extension detected the page but couldn't identify specific media sources. Try playing the video first, then open the popup again.

**I'm getting mixed results on different Borwap pages**
Borwap uses both http and https across wildcard subdomains, and not all pages follow the same structure. The extension is a generic baseline, not a polished extractor.

### 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/borwap-downloader](https://serp.ly/borwap-downloader)

### Installation Instructions

1. Open the latest release page: [GitHub Releases](https://github.com/serpcompany/borwap-downloader/releases/latest)
2. Download the correct build for your browser.
3. Install the extension.
4. Open a supported Borwap page.
5. Use the popup to detect and download the media.

### FAQ

**What makes Borwap different from more modern video platforms?**
Borwap uses a mixed http/https surface with wildcard subdomains and older WAP-style routes like `/en/download/...?...` and `xxx_new.jsp`. This legacy structure requires special handling.

**Is the current sample URL the best example page for testing?**
No. The current sample is flagged as a weak example and may not be the final best repro page for validation.

**Are player-button, context-menu, or offscreen features confirmed?**
No. Those details were not confirmed in the available data and should not be expected in this candidate-stage version.

**Is this a proven released downloader?**
No. This is a candidate-stage tool. Real extraction review is still needed, and release proof is not yet confirmed.

**Can I use this extension on other websites?**
The extension is specifically designed for Borwap URL patterns. It may not work on other platforms.

### Notes

- Only download content you own or have explicit permission to save
- An internet connection is required for downloads
- The current sample quality is weak, and not all Borwap pages may work reliably
- This is a candidate-stage tool, not a proven release

### License

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

### About Borwap

Borwap is an older WAP-style platform that serves video content through legacy URL patterns and mixed protocol coverage. Borwap Downloader provides a conservative candidate for users who need to save media from these non-standard pages.

# 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("serpdownloaders/borwap-video-downloader-how-to-download-borwap-videos").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("serpdownloaders/borwap-video-downloader-how-to-download-borwap-videos").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 serpdownloaders/borwap-video-downloader-how-to-download-borwap-videos --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=serpdownloaders/borwap-video-downloader-how-to-download-borwap-videos",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Borwap Video Downloader | How to Download Borwap Videos",
        "description": null,
        "version": "0.0",
        "x-build-id": "pseajsEbUpMpvJxOi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/serpdownloaders~borwap-video-downloader-how-to-download-borwap-videos/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-serpdownloaders-borwap-video-downloader-how-to-download-borwap-videos",
                "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/serpdownloaders~borwap-video-downloader-how-to-download-borwap-videos/runs": {
            "post": {
                "operationId": "runs-sync-serpdownloaders-borwap-video-downloader-how-to-download-borwap-videos",
                "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/serpdownloaders~borwap-video-downloader-how-to-download-borwap-videos/run-sync": {
            "post": {
                "operationId": "run-sync-serpdownloaders-borwap-video-downloader-how-to-download-borwap-videos",
                "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```