Website profiles · Technology insights · Alternatives

invidious.io

Invidious is an open source alternative front-end to YouTube.

Development Open Source

No paid content found

Visit website

Profile views 7 Outbound visits 13 Normal

At a glance

Category: Development
Language: English
Paid-content signal: No paid content foundObserved
Registered: 2021
Hosting: 1984 ehfInferred
HTTPS certificate trusted: PassedObserved
Last updated: 2026-09-24 03:07

Website review

This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.

What is Invidious?

Invidious is an open source alternative front-end to YouTube. Instead of watching videos on YouTube itself, you use an Invidious instance that pulls the same content and presents it in a simpler, privacy-oriented interface. It is free (libre) software licensed under AGPL-3.0, and anyone can host an instance.

What it changes in practice

Privacy: It is designed to shield you from Google's tracking rather than profile your viewing.
No ads: Videos play without YouTube's ad interruptions, with SponsorBlock supported.
Accounts without YouTube: You can subscribe to channels and build playlists without a Google account.
Multilingual: Translations make the interface available in many languages.
Developer API: A documented REST API lets developers build on top of it.

When it makes sense

If your main goal is watching YouTube links without ads, tracking, or a Google login, Invidious fits well. If you rely on YouTube's recommendation feed, comments, or creator monetization features, expect a narrower experience — it is a front-end, not a full replacement.

A practical next step: try a public instance with a video you already know, then decide whether to use one regularly or self-host. For the software and hosting details, see Invidious; the code lives on GitHub, and the official YouTube alternative front-end ecosystem includes GitHub for source and issue tracking.

How does Invidious protect my privacy compared to YouTube?

Invidious is a privacy-focused alternative front-end to YouTube: you watch YouTube-hosted videos through Invidious's interface rather than YouTube's own site, so your viewing activity isn't tied to a Google account or used to build an ad profile in the way it is on YouTube itself. The project describes itself as "privacy focused," stating it won't track you, and as ad-free, with SponsorBlock support for skipping sponsored segments.

The practical difference is what data each interface collects and exposes:

Aspect	YouTube (native site)	Invidious
Account needed to watch	Not strictly, but sign-in drives recommendations and history	No account needed to watch
Subscriptions and playlists	Tied to your Google account	Available without a YouTube account
Ads	Ad-supported	Ad-free per the project
Tracking for recommendations	Core to the experience	Not part of the design goal
Software model	Proprietary service	Free/libre, AGPL-3.0, self-hostable

A few caveats matter in practice. Invidious is a front-end, not a separate video host — the video streams still originate from YouTube's infrastructure, so your requests ultimately reach Google's servers, and the privacy you get depends on how the particular Invidious instance is run and whether you trust its operator. Anyone can host an instance, so a public instance's logging policy is set by whoever runs it, not by the Invidious project. Self-hosting gives you the most control. Also note that "no account" doesn't mean "no data": without sign-in, subscriptions and playlists live in that instance or your browser rather than in a Google profile.

Next step: if you want the strongest privacy position, run your own instance from the source code and check what the instance you use logs; if you just want ad-free, account-free viewing, try a well-known public instance and see whether subscriptions and playlists behave the way you need. For background on the parent platform, see YouTube.

Can I subscribe to channels and create playlists on Invidious without a YouTube account?

Yes. Invidious is built to let you follow channels and organize playlists using its own account system, so a YouTube/Google login isn't required. Its page lists "Accounts" as a core feature and explicitly says you can subscribe to channels and create playlists without needing a YouTube account.

What that looks like in practice

You create an Invidious account on a public instance (or a self-hosted one), then subscribe to channels there.
Your subscriptions and playlists live in Invidious, not in your YouTube account.
Playlists can be built from videos you find through Invidious, and you can revisit them when signed in.

Trade-offs to expect

Your subscriptions are tied to that Invidious account and instance, not to YouTube, so they won't sync back to YouTube.
If you use a public instance, availability and performance can vary; some instances restrict account creation. Self-hosting avoids that but requires more setup.
Because Invidious is an alternative front-end, some YouTube-specific features may behave differently or be unavailable.

A practical next step

Pick an instance, create an account there, and test the workflow with one channel and one small playlist before moving your full subscription list. If account creation is disabled on the instance you try, look for another instance or consider self-hosting. For project details and documentation, see Invidious.

How do I host my own Invidious instance?

You can host your own Invidious instance by deploying the open-source software yourself. Invidious is an alternative front-end to YouTube, licensed under AGPL-3.0, and the project explicitly offers a "Host Invidious" option alongside its public instances Invidious. Hosting means running the server and database on infrastructure you control, rather than relying on someone else's instance.

What you are actually setting up

Self-hosting gives you an instance that is privacy-focused, ad-free, and supports SponsorBlock, with accounts for subscriptions and playlists without a YouTube login Invidious. These are the same features users get on public instances; the difference is that you own the deployment, the domain, and the data flow.

Practical steps

Check the official documentation first. The site links to Documentation and a GitHub repository Invidious. Use those for current install instructions, dependencies, and configuration options rather than relying on third-party guides.
Choose your infrastructure. A small VPS or a home server is typical. Video proxying can be bandwidth-heavy, so a host with generous transfer is more suitable than the cheapest tier.
Plan for updates. Because you run the software, you are responsible for pulling new releases, applying database migrations, and watching for breaking changes. This is the main ongoing cost of self-hosting.
Consider the legal and network reality. Your instance fetches content from YouTube on behalf of viewers; IP blocks and rate limiting are common operational issues, so expect to troubleshoot.

When self-hosting makes sense

You want a private instance for yourself, family, or a small community.
You need the REST API for a development project and want a stable endpoint you control Invidious.
You are comfortable with server administration and ongoing maintenance.

If you only want ad-free, tracker-free viewing and do not want to run a server, using an existing public instance is the simpler path. For the actual install commands, start with the Documentation and GitHub links on Invidious.

What is the Invidious API and how can I use it for development?

The Invidious API is a documented REST interface that exposes Invidious's YouTube proxy functionality to developers. Instead of scraping YouTube or embedding its player, you send HTTP requests to an Invidious instance and receive structured JSON: video metadata, channel and playlist data, search results, comments, captions and trending feeds. Because Invidious itself is an alternative front-end that fetches YouTube content server-side, your application never talks to YouTube directly.

Invidious describes the API as "fully featured and documented" and aimed at developers.

What you can build with it

A privacy-respecting YouTube client for desktop or mobile that renders its own UI.
A search or discovery tool that queries videos, channels and playlists without a YouTube API key.
A metadata pipeline for archiving, research or media monitoring.
A lightweight embed alternative for a site that wants playback without YouTube's tracking scripts.

How to start

Pick an instance. Invidious is software you can self-host, and public instances are run by volunteers. Instance availability and rate limits vary, so test a few and check their status pages.
Read the API documentation linked from the project (the page lists Documentation and a Developer API section).
Call an endpoint such as the video or search route and inspect the JSON shape before writing your data model.
Handle failure gracefully: instances can go down, block requests or throttle heavy callers.

Practical trade-offs

Consideration	Implication
Public instances	Free to use, but availability and rate limits are outside your control
Self-hosting	Full control and predictable limits, but you run and maintain the server
No YouTube account needed	Simplifies auth; subscription and playlist features are handled by Invidious accounts
YouTube-facing dependency	If YouTube changes its internals, instances may break until updated
Licensing	The project is AGPL-3.0, which matters if you modify and distribute the code

A concrete scenario: you are building a small research dashboard that tracks a set of channels. Rather than applying for YouTube API quotas, you query an Invidious instance for channel videos and store the JSON yourself. The trade-off is reliability — you are depending on a volunteer-run service, so caching responses and supporting a fallback instance is sensible engineering.

Next step: open the Documentation link on Invidious, choose one endpoint, and make a single test request against a public instance before designing your integration.

How does Invidious integrate with SponsorBlock to skip ads and sponsors?

Invidious supports SponsorBlock, which means it can automatically skip sponsor segments in videos. The feature is built into the Invidious front-end rather than requiring a separate browser extension. According to the project's own description, Invidious is "100% supported by SponsorBlock," and it also removes ads served by YouTube.

How it works in practice

No Google account required. You watch through an Invidious instance, and SponsorBlock data is applied to the video playback there.
Segment categories. SponsorBlock works on crowd-sourced segment categories such as sponsors, intros, outros, self-promotions and subscription reminders. Invidious lets you control which categories are skipped.
Per-instance behavior. Invidious is self-hosted software, so the exact SponsorBlock settings and defaults depend on the instance you use. Public instances may differ in whether SponsorBlock is enabled and which categories are active.

What this means for you

If you mainly want sponsor skipping without installing an extension, Invidious is a reasonable fit. If you want fine-grained, per-category control with a large user base and consistent behavior, the official SponsorBlock browser extension is the more direct tool; Invidious is better seen as a privacy-oriented YouTube front-end that happens to include SponsorBlock support.

A practical next step: open a public Invidious instance, play a video known to contain a sponsor read, and check the settings panel for SponsorBlock categories before deciding whether to self-host. For self-hosting, the project's documentation at Invidious covers instance setup and configuration.

For comparison, SponsorBlock's own project is at SponsorBlock.

What "open-source UI element library" actually means

The term gets used loosely, so it helps to separate the parts:

Open-source: the code is publicly available, and the license tells you what you may do with it—copy, modify, redistribute, or use commercially.
UI element: a single, self-contained piece of interface, usually small enough to read in one sitting. A button with hover states, a pricing card, a search field.
Library: a browsable, searchable collection of those elements, typically contributed by many different people.

On a site like Uiverse, elements are shared by a community and written in plain CSS or Tailwind. You find one you like, copy the markup and styles, paste them into your project, and adjust colors, spacing, and text to fit. There's no package to install and no build step required—which is exactly the appeal, and also the source of most of the confusion.

Element library vs. UI framework: the core differences

Dimension	Open-source UI element library	UI framework / design system
Unit of reuse	A single snippet you copy	A component you import or call
Installation	None; paste into your code	Package install, config, sometimes a provider
Consistency	Depends on you; each element may look different	Enforced by shared tokens and APIs
Theming	Manual edits per element	Central theme/config file
Updates	You own the copy; no upstream updates	Version bumps bring fixes and changes
Accessibility	Varies per contributor; must be checked	Usually tested and documented
Best for	Prototypes, landing pages, small sites, one-off needs	Multi-page apps, teams, long-lived products
Learning curve	Low—read the CSS	Higher—learn the API and conventions

The table isn't a verdict. It's a map of trade-offs. Element libraries win on speed and freedom; frameworks win on consistency and maintenance.

Licensing and attribution: what to check before you paste

This is where people get into trouble, and it's worth slowing down for.

Find the license. Every element or collection should state one. Common open-source licenses include MIT, Apache-2.0, and BSD. Some projects use copyleft licenses like GPL, which can impose obligations if you redistribute your code.
Understand what the license permits. MIT and Apache-2.0 are permissive: you can typically use the code in commercial and closed-source projects. Copyleft licenses may require you to release derivative source under the same terms.
Check attribution requirements. Permissive licenses usually require you to keep the copyright notice and license text somewhere in your project. That's a real obligation, not a formality.
Look for per-element terms. On community sites, the site's overall terms and the individual contributor's stated wishes may differ. If a contributor asks for credit, honor it.
When in doubt, ask or avoid. If a snippet has no license at all, you don't have clear permission to reuse it. Treat "no license" as "not open source," even if the code is publicly visible.

This article is general information, not legal advice. For commercial products with real exposure, have someone qualified review the licenses you're relying on.

How to use a community element in your project: a practical workflow

Here's a repeatable process that avoids most of the usual mess.

1. Start from a real need, not a browsing session

Decide what you need first—"a compact primary button with a loading state"—then search. Browsing aimlessly produces a pile of pretty snippets that don't fit together.

2. Copy the smallest version that works

Take the markup and the styles. Strip anything you don't need: demo wrappers, extra animations, decorative layers. Less code means fewer surprises.

3. Convert it to your conventions

If your project uses design tokens or CSS variables, replace hard-coded values:

/* Before: hard-coded */
.button { background: #4f46e5; border-radius: 8px; }

/* After: token-based */
.button { background: var(--color-primary); border-radius: var(--radius-md); }

This one step is what keeps a copied element from looking like a foreign object in your UI.

4. Check accessibility before you ship

Community elements vary widely here. Verify at minimum:

Keyboard focus is visible and the element is reachable by Tab.
Color contrast meets WCAG AA (4.5:1 for normal text).
Interactive elements use semantic HTML (<button>, not a clickable <div>).
Form inputs have associated labels.
Motion respects prefers-reduced-motion.

5. Test in context

Paste it into a real page with real content. Long labels, small screens, and dark mode break more copied elements than anything else.

6. Note where it came from

Keep a short comment or an internal credits file: source, license, date. Future you—and your legal reviewer—will be grateful.

Where element libraries genuinely shine

Prototypes and demos: you need something clickable today, not a design system.
Landing pages and marketing sites: a handful of distinctive elements, each custom.
Filling gaps: your framework lacks one specific component, and you don't want to build it from scratch.
Learning: reading well-made CSS is one of the fastest ways to improve.
Small projects: a personal site doesn't need a theming architecture.

Where they fall short

Consistency at scale: ten elements from ten contributors rarely look like one product.
Maintenance: you own every copy. When your design changes, you edit each one.
Accessibility debt: you inherit whatever the contributor did or didn't do.
No upstream fixes: a bug fixed in the original won't reach your copy.
Integration friction: different naming conventions, different units, different assumptions about resets.

When to choose which

Choose an element library when the scope is small, the timeline is short, or you need a few distinctive pieces rather than a whole system.

Choose a framework or design system when multiple people build multiple screens over months, when consistency is a product requirement, or when accessibility and theming need to be guaranteed rather than checked.

A hybrid works well for many teams: adopt a framework for the structural components—forms, navigation, layout—and borrow individual elements for the places where you want personality. Just route every borrowed element through the same token and accessibility checks, so it lands as part of your system rather than beside it.

The short version: open-source UI element libraries are a fast, flexible way to get good-looking interface pieces into a project. They are not a substitute for a design system, and the license and accessibility details are the part worth reading carefully.

Website Overview

Limited stack disclosure and few obvious backend markers suggest a more restrained public footprint. That reduces easy fingerprinting clues but is not proof of overall security. Page metadata, canonical configuration and social previews work together to provide more consistent search and sharing presentation.

Domain and Registration

Transfer-protection status is present, helping reduce the risk of unauthorized domain transfers. The domain has about 5 years of registration history; its current configuration provides more context than age alone. The domain uses the common .io extension, which is not an independent safety signal.

DNS and Email

The lowest TTL is 60 seconds, supporting rapid record changes at the cost of more frequent lookups. Nameservers are provided by njalla.no, indicating managed DNS hosting. MX records point to the runbox.com email service. DNSSEC is enabled, allowing validating resolvers to authenticate signed DNS data. No CNAME was found; the observed records resolve directly to addresses.

TLS and Certificates

The public key uses EC with 256 bits. The server supplied a complete certificate chain. No organization name is present in the certificate; the available fields are consistent with domain validation. The certificate was issued by Let's Encrypt, commonly associated with automated certificate services. The certificate's total validity is about 89 days, consistent with a short renewal cycle.

HTTP and Browser Security

The Server header exposes the software version: Caddy, nginx/1.29.2. This makes version-targeted checks easier, but is not proof of an exploitable vulnerability. The checked browser-security headers were not detected, leaving fewer explicit browser-side safeguards. No X-Powered-By header was found, reducing one common source of backend fingerprinting information. No obvious internal addresses or debug information were found in the headers. No explicit CDN or WAF marker was found in the response headers.

Technology Stack Analysis

No obvious technology stack is exposed. This may reflect restrained information disclosure, although the underlying technologies remain unknown.

Search and Social Sharing

Open Graph is partially configured; og:image is missing. Twitter Card metadata is configured. The title has 59 characters, within a common display range. A meta description is present, with 61 characters. The observed directives allow indexing and link following.

Hosting and Email

DNSnjalla.no

Hosting1984 ehf

Emailrunbox.com

Approximate IP geolocation (inferred; a CDN or proxy may differ from the origin server) Iceland Inferred 93.95.230.186

Registration details

RDAP / WHOIS

Registrar	Immaterialism Limited
Registered	2021-01-06
Expires	2028-01-06
Domain status	clientTransferProhibited https://icann.org/epp#clientTransferProhibited
Nameservers	1-you.njalla.no、2-can.njalla.in、3-get.njalla.fo
DNSSEC	signed

DNS records

DNS

Type	Name	Value	TTL	Priority
A	invidious.io	93.95.230.186	21600	—
AAAA	invidious.io	2001:470:1f1c:685::2	60	—
MX	invidious.io	mx.runbox.com	21600	10
NS	invidious.io	1-you.njalla.no	36000	—
NS	invidious.io	2-can.njalla.in	36000	—
NS	invidious.io	3-get.njalla.fo	36000	—
TXT	invidious.io	v=spf1 redirect=spf.runbox.com	21600	—
DS	invidious.io	42647 8 2 bbfc258a77c04e7aa96cf823fb07b0f91235d621657aaf3d57f55e146ca8100d	3600	—
DMARC	_dmarc.invidious.io	v=DMARC1; p=reject;	21600	—

TLS and certificates

TLS / SSL

Assessment	Normal configuration
Supported protocols	TLSv1.2、TLSv1.3
Negotiated protocol	TLSv1.3
Certificate subject	invidious.io
Issuer	Let's Encrypt
Valid until	2026-12-10T10:10 · Remaining when checked: 77 days
Verification details	Certificate trust: Passed · Hostname match: Passed

HTTP response headers

HTTP

Header	Value
content-type	text/html
server	Caddy, nginx/1.29.2

Identified technologies

Technology stack: Unknown

Pages, Search and Sharing

Meta description	Invidious is an open source alternative front-end to YouTube.
Canonical URL	https://invidious.io/
Language	English (default)
Twitter Card	summary_large_image

Social Sharing Preview

9 fields

Sharing metadata

og:url	https://invidious.io/(opens in a new tab)
og:type	website
og:title	Invidious
og:site_name	Invidious
og:description	Invidious is an open source alternative front-end to YouTube.
twitter:card	summary_large_image
twitter:title	Invidious
twitter:image:alt	Invidious
twitter:description	Invidious is an open source alternative front-end to YouTube.

robots.txt (opens in a new tab)

0 rules

All bots 0 allowed · 0 disallowed

Sitemaps

No sitemaps found

Recent Updates

Website images2026-09-24 03:18
Screenshots2026-09-24 03:18
Network details2026-09-24 03:18
Website Technologies2026-09-24 03:18
Pages and Search Information2026-09-24 03:18
TLS and certificates2026-09-24 03:18

User reviews (0)

No reviews yet.