# Inporn Video Downloader | How to Download Inporn Videos (`how-to-download-videos/inporn-video-downloader-how-to-download-inporn-videos`) Actor

- **URL**: https://apify.com/how-to-download-videos/inporn-video-downloader-how-to-download-inporn-videos.md
- **Developed by:** [how-to-download-videos](https://apify.com/how-to-download-videos) (community)
- **Categories:** Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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

## Inporn Video Downloader | How to Download Inporn Videos

> Download InPorn videos from direct `/video/<id>/<slug>/` pages with simple player handoff framing and cautious m3u8/mp4 support.

### Get it Here

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

![Inporn Downloader](https://apps.serp.co/media/optimized-products/inporn-downloader-homescreen-adult-0539e82441.webp)

Inporn Downloader is a browser extension built specifically for InPorn's clean numeric video page structure. Instead of using generic copy that could describe many unrelated sites, this tool is anchored to InPorn by name and its straightforward page-to-player flow. The extension follows the simple path from an InPorn catalog click into a dedicated video page, then into the embedded player where media may become visible.

- Built around InPorn's direct `/video/<id>/<slug>/` page structure
- Follows the natural handoff from page entry to embedded playback
- Detects m3u8 playlists or direct mp4 files when exposed by the player
- Brand-specific positioning instead of interchangeable batch copy
- Verified target status with careful readiness language
### Table of Contents

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

### Why Inporn Downloader

Many video downloader extensions use the same recycled language for every adult site, treating them all as interchangeable targets. Inporn has its own page structure built around a clean numeric URL pattern like `/video/445/paris-white-108/`. A generic tool that ignores that structure may miss the moment when the page hands off into the embedded player, leaving you without a usable media source.

Inporn Downloader is written specifically for Inporn's direct video page format. It follows the natural flow from a catalog click into the video page, then into the player or iframe where m3u8 playlists or mp4 files may be exposed. This focused approach means the extension stays honest about what Inporn pages look like and how they deliver media, rather than making broad promises that may not apply.

### Features

- Built specifically for Inporn's `/video/<id>/<slug>/` page pattern
- Follows the page-to-player handoff for media detection
- Detects m3u8 playlist streams when available
- Detects direct mp4 file delivery when exposed
- Simple popup interface for download control
- No generic batch copy or site-agnostic claims
- Verified target status with transparent readiness
- Privacy-focused local saving workflow

### How It Works

1. Install the extension from the latest release.
2. Open Inporn 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 Inporn

1. Navigate to any Inporn video page that follows the `/video/<id>/<slug>/` pattern.
2. Wait for the page to fully load and the embedded player to appear.
3. Start video playback so the player exposes the media stream.
4. Click the extension icon in your browser toolbar to open the popup.
5. Allow the extension to detect available media sources from the player.
6. Review the detected options, which may include m3u8 playlists or mp4 files.
7. Select your preferred quality or format option from the list.
8. Click download and save the resulting MP4 file to your local device.

### Supported Formats

- Input: m3u8 playlists and direct mp4 files exposed through Inporn's embedded player or iframe handoff
- 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

- People browsing Inporn who want a direct download path from video pages
- Users who prefer brand-specific tools over generic site-agnostic extensions
- Anyone looking for a cleaner way to save Inporn content they have rights to
- Viewers who want to build a local library of Inporn videos for offline access

### Common Use Cases

- Saving a favorite Inporn video for offline viewing without buffering
- Archiving Inporn content that may become unavailable in the future
- Building a personal collection of Inporn videos organized by preference
- Moving Inporn downloads to other devices for playback on different screens
- Keeping a backup copy of Inporn videos you own or have permission to save

### Troubleshooting

**The extension does not detect any media on the video page.**
Make sure the video player has fully loaded and playback has started. The media source may not be exposed until the player initiates streaming.

**I see a message about generated stub behavior.**
This extension is a verified target with strong signals, but the adapter is still in candidate stage. Updates will improve detection reliability over time.

**The download starts but fails before completing.**
Check your internet connection and try again. Some m3u8 streams may have fragmented delivery that requires a stable connection.

**Only one quality option appears.**
Inporn may only expose a single stream variant for some videos. Quality options depend on what the page and player deliver.

**The popup does not open on the video page.**
Refresh the page and ensure you are on a direct `/video/<id>/<slug>/` URL. Catalog pages and search results are not supported.

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

### Installation Instructions

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

### FAQ

**What makes this different from other Inporn downloaders?**
This extension is built around Inporn's actual page structure, specifically the `/video/<id>/<slug>/` pattern and the player handoff flow, rather than using generic copy that could apply to any site.

**Is Inporn a verified target for this extension?**
Yes, Inporn is marked as target-verified and target-ready. However, the adapter is still in candidate stage with some caveats about config identity and generated stub behavior.

**What video formats does the extension support?**
The extension looks for m3u8 playlists and direct mp4 files that Inporn's embedded player may expose during playback.

**Do I need an account to use the extension?**
You need a SERP account for the trial and paid access, but no Inporn account is required to download videos from public pages.

**Can I download multiple videos at once?**
The extension is designed for individual video downloads from direct Inporn video pages. Bulk download is not supported.

### Notes

- Only download content you own or have explicit permission to save
- An internet connection is required for downloads
- Inporn Downloader is a verified target with strong signals, but adapter readiness is still in candidate stage
- The extension focuses on Inporn's direct `/video/<id>/<slug>/` page pattern and player handoff flow

### License

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

### About Inporn

Inporn is an adult video platform that organizes content through a clean numeric URL structure. Each video lives at a direct `/video/<id>/<slug>/` path, making it a straightforward target for a focused downloader that follows the page-to-player handoff rather than relying on broad site-agnostic methods.

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

```

## MCP server setup

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

```

## OpenAPI specification

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