mediapeek.plnk.workers.dev

MediaPeek is a browser-based tool that inspects media metadata from a URL and shows it in a structured interface. It fits when you need to identify codecs, formats, or badge-level details (resolution, HDR, audio type) of a file you can reach by link — including large files — without downloading the whole thing. It accepts HTTP/HTTPS URLs and public Google Drive files and folders, and it can look inside ZIP and TAR archives.

What it does

MediaPeek covers four tasks, from fetching to sharing:

• Partial fetching. It reads only the bytes needed from a URL using byte-range HTTP requests, so no full download is required even for large files. Requests are edge-processed near the user.
• Archive support. It looks inside ZIP (Stored, DEFLATE) and TAR (standard + @LongLink) archives without extracting the full file, and keeps the archive name visible so you retain archive → filename context.
• Multiple exports. Metadata can be exported as Object JSON, Text, HTML, or XML — readable for humans or machine-parseable for pipelines.
• Encrypted sharing. Results can be shared through encrypted links. MediaPeek states it does not store the content, and the key stays in the URL (end-to-end encryption via PrivateBin).

How the metadata engine works

Analysis runs in the browser through mediainfo.js v0.3.7, a WebAssembly port of MediaInfoLib (v 25.10, © 2002–2026 MediaArea.net SARL). Because parsing happens in WebAssembly, the inspection is based on the same MediaInfo library widely used for media file identification, rather than a proprietary parser.

A practical example: if you have a link to a multi-gigabyte video and want to confirm whether it is HDR10+ with a lossless audio track, MediaPeek fetches the header and relevant byte ranges, parses them with mediainfo.js, and returns the metadata — you never pull the full file.

Format badges and attribution

Badge assets for consistent media labeling come from Apple TV (SD, HD, 4K, HDR, HDR10+, and related video badges) and Apple Music (Lossless, Hi-Res Lossless, Apple Digital Master, Spatial Audio, AAC). Third-party marks remain the property of their owners and are referenced for identification only; the site lists notices for Dolby, IMAX, DTS, HDR10+, and AV1.

Who it suits

Practical notes

• Open source. MediaPeek is built in public and maintained on GitHub, where you can review issues, track releases, and follow development.
• No pricing information is provided on the site, so cost or account requirements are not established here.
• Privacy model. Content is not stored by MediaPeek, but the sharing key travels in the URL — treat shared links as sensitive.

To try it, open the app from the MediaPeek homepage and paste a supported URL.

MediaPeek reads only the parts of a file it needs to identify its metadata, using byte-range HTTP requests instead of downloading the whole file. You give it an HTTP/HTTPS URL or a public Google Drive file or folder, and it parses the metadata in your browser through a WebAssembly build of the MediaInfo library. That means large files can be inspected without waiting for a full transfer, and the analysis runs near you at the edge rather than on a central server.

How partial fetching works

The core mechanism is the HTTP Range header. Instead of requesting the entire file, MediaPeek asks the host for specific byte ranges — typically the container headers at the start of the file and the index or footer at the end. Media metadata such as codec, resolution, duration, and track layout is usually described in those structures, so the tool can report it without touching the media payload in between.

The practical effect: a multi-gigabyte video can be inspected in seconds, and bandwidth use stays small. The trade-off is that the source must support range requests. A plain static file server or Google Drive's public file endpoints generally do; a URL that streams from a server which ignores Range headers, or one behind authentication, may not work.

What it accepts

For archives, MediaPeek looks inside without extracting the full file and keeps the archive name visible so you can tell which file a result came from.

The metadata engine

Parsing is done by mediainfo.js v0.3.7, a WebAssembly port of MediaInfoLib v25.10 (copyright MediaArea.net SARL). Because it runs in WebAssembly, the analysis happens in the browser environment close to the user rather than being uploaded to a backend. MediaPeek states that it does not store the content.

This matters for two reasons. First, the same library that powers desktop MediaInfo produces the results, so field names and format detection should look familiar. Second, the file itself is never fully transferred to a server for analysis — only the byte ranges needed for parsing are fetched.

Sharing and export

Results can be exported as Object JSON, Text, HTML, or XML, depending on whether you need something human-readable or machine-parseable. Sharing uses encrypted links via PrivateBin: the key stays in the URL fragment, and MediaPeek does not store the content. Anyone with the full link can decrypt the result; without the fragment, the shared data is not readable.

When this approach fits — and when it doesn't

Use MediaPeek when you have a direct, publicly reachable URL and want a quick read on codec, resolution, duration, or track details without pulling the file down. It is also useful for peeking inside ZIP or TAR archives to see what media they contain before extracting.

It is a poor fit when the URL requires login, when the host does not honor range requests, or when you need frame-level analysis rather than container metadata. In those cases you would need to download the file and inspect it locally.

Verifying a result

1. Open the app and paste an HTTP/HTTPS URL or a public Google Drive link.
2. Confirm the fetch completes and metadata appears — a failure here usually points to a blocked range request or a private resource.
3. Cross-check a known field (for example, duration or resolution) against the file's own player or ffprobe output.
4. Export as JSON if you need to compare fields programmatically.

The most common snag is a URL that looks public but sits behind a redirect or token check; if the fetch fails, test the same URL with a direct curl -r 0-1023 request to see whether range access is actually permitted.

MediaPeek parses media metadata with mediainfo.js v0.3.7, a WebAssembly port of MediaInfoLib v25.10, and the project is open source — its source code, issues, and releases are maintained publicly on GitHub. This matters if you want to know what is actually reading your files and whether you can verify or self-host the tooling.

The metadata engine

MediaPeek's "Metadata engine" section states the parsing stack directly:

The practical consequence: metadata analysis runs in WebAssembly rather than on a remote server. Combined with MediaPeek's partial-fetch design, the app reads only the byte ranges it needs from a URL and parses them locally in the browser. For example, if you point it at a large video file, it does not need a full download to report codec, resolution, or bitrate information.

MediaPeek credits the library explicitly: mediainfo.js is a WebAssembly port of MediaInfo, copyright (c) 2002–2026 MediaArea.net SARL.

Open source and maintenance

The site describes MediaPeek as "built in public, maintained on GitHub." From the project page you can:

• Browse the source code repository
• Review open issues
• Track releases
• Follow ongoing development

That gives you a way to check how the WebAssembly parsing is wired up, confirm version bumps, and see whether reported problems are being addressed — rather than taking the engine description on faith.

Third-party badges and trademarks

MediaPeek displays format badges sourced from Apple TV (SD, HD, 4K, HDR, HDR10+) and Apple Music (Lossless, Hi-Res Lossless, Apple Digital Master, Spatial Audio, AAC). The site notes that third-party marks remain the property of their respective owners and are referenced for identification only. Trademark notices cover Dolby (Dolby Vision, Dolby Atmos, Dolby Audio), IMAX, DTS and DTS:X, HDR10+, and AV1 (Alliance for Open Media).

What this means for you

• If you need to verify the parser: the mediainfo.js/MediaInfoLib versions are published, and the GitHub repository lets you inspect the implementation.
• If you care about where analysis happens: parsing is WebAssembly-based, consistent with the browser-side, partial-fetch approach described on the site.
• If you need licensing clarity for badges: the site attributes badge assets and trademarks to their owners; it does not state separate licensing terms for those assets beyond that attribution.

Yes. MediaPeek can look inside ZIP and TAR archives without extracting the full file, and it keeps the archive name visible so you can tell which archive a given filename came from. This applies to ZIP archives using Stored or DEFLATE compression and to standard TAR archives, including those that use @LongLink entries for long filenames.

What archive support actually covers

MediaPeek's archive handling is built for inspecting media metadata, not for unpacking files to disk. The site describes it as looking inside archives "without extracting the full file," which means you get metadata for the media entries inside the archive while the archive itself stays intact.

How the inspection works

MediaPeek fetches only the bytes it needs from a URL using byte-range HTTP requests, so even large files don't require a full download. Metadata parsing runs in WebAssembly via mediainfo.js (v0.3.7), a port of MediaInfoLib (v25.10). For archives, that same partial-fetch approach lets it read archive structure and entry data rather than pulling the entire file.

The practical flow is:

1. Provide a URL to a media file or archive. Supported sources are HTTP/HTTPS URLs and public Google Drive files and folders.
2. MediaPeek issues byte-range requests to read only the necessary portions.
3. The metadata engine parses the result in your browser via WebAssembly.
4. You see metadata for the media, with the archive name preserved as context for entries inside ZIP or TAR files.

When this is useful

Archive inspection helps when media is packaged rather than loose. For example, if you have a ZIP of video files from a delivery and want to check resolution, codec, or HDR badges before unpacking, MediaPeek can read the entries and show their metadata while keeping the archive name attached. The same applies to TAR archives, including those with long filenames handled through @LongLink.

Limits to keep in mind

• Only ZIP (Stored, DEFLATE) and TAR (standard + @LongLink) are listed as supported archive formats. Other compression schemes aren't described.
• Sources are limited to HTTP/HTTPS URLs and public Google Drive files and folders.
• The tool inspects metadata; it doesn't present itself as a general-purpose extractor.

Sharing and exports

Results can be exported as Object JSON, Text, HTML, or XML. Sharing uses encrypted links via PrivateBin: MediaPeek doesn't store the content, and the key stays in the URL. Badge assets for formats like SD, HD, 4K, HDR, and audio labels come from Apple TV and Apple Music, and MediaPeek is open source with its repository on GitHub.

MediaPeek lets you export inspected metadata as Object JSON, plain Text, HTML, or XML, and share results through an encrypted link. The export choice depends on whether a person or a tool will consume the output; the sharing option is for handing results to someone else without MediaPeek storing the content. Both features apply to metadata MediaPeek has already read from a URL, including files inside supported ZIP and TAR archives.

Export formats

MediaPeek describes four export formats, split between human-readable and machine-parseable output.

The site frames the choice as "the format that fits your workflow — whether you need something readable or machine-parseable." In practice:

• Choose Object JSON when another program will parse the result, for example feeding track and codec fields into a catalog or a validation script.
• Choose Text when you only need to read or forward the values, such as checking resolution and audio format before publishing a file.
• Choose HTML when the result should render as a formatted page rather than raw text.
• Choose XML when the receiving tool or template is built around XML.

The export covers the metadata MediaPeek has analyzed, not the media file itself. MediaPeek reads metadata using mediainfo.js (a WebAssembly port of the MediaInfo library, version 0.3.7, based on MediaInfoLib 25.10), so exported fields reflect what that engine reports.

Encrypted sharing

MediaPeek shares results through encrypted links. Per the site:

• Sharing uses end-to-end encryption via PrivateBin.
• MediaPeek does not store the content.
• The key stays in the URL.

That last point matters operationally: anyone who has the full link can open the shared result, so treat the link itself as the secret. Send it through a channel you trust, and avoid posting it publicly if the metadata is sensitive. Because the key travels in the URL fragment rather than being held by the service, the sharing model depends on the recipient receiving the complete link.

How to use them

1. Open the MediaPeek app and submit a URL — an HTTP/HTTPS URL or a public Google Drive file or folder. For archives, MediaPeek can look inside ZIP (Stored, DEFLATE) and TAR (standard and @LongLink) files without extracting the whole archive, keeping the archive name visible for context.
2. Wait for the metadata analysis to complete. Fetching is partial: MediaPeek reads only the bytes it needs via byte-range HTTP requests, so large files don't require a full download.
3. Pick an export format — Object JSON, Text, HTML, or XML — depending on whether a person or a tool will use the result.
4. To hand the result to someone else, create an encrypted share link. Copy the entire URL, including the key portion, and send it to the recipient.

Common snags

• Truncated share links fail. If a chat app or email client cuts off the URL, the key is lost and the result can't be decrypted. Verify the full link arrived intact.
• Wrong format for the next step. Exporting Text when a downstream parser expects JSON (or vice versa) means re-running the inspection. Decide the consumer before exporting.
• Assuming the link is private by default. The key is in the URL, so the link's confidentiality depends on where you send it.
• Expecting the media file in the export. Exports contain metadata, not the underlying media; the partial-fetch design is about reading metadata efficiently, not retrieving full files.

MediaPeek is open source and maintained on GitHub, so the export and sharing behavior can be checked against the repository and its releases if you need to confirm details for a specific version.