Forem: Tarun yadav

AI Voiceover for YouTube: No Subscription Required

Tarun yadav — Mon, 13 Apr 2026 08:37:47 +0000

How YouTube creators generate voiceovers locally on their Mac without paying monthly fees or uploading scripts to the cloud.

The Voiceover Problem for YouTube Creators

Faceless YouTube channels are everywhere. Finance explainers, tech tutorials, true crime compilations, history deep dives. They pull millions of views without ever showing a face. What they all need is a consistent, engaging voice. And for most creators, the voice question is the biggest production bottleneck.

Recording your own voiceover works, but it demands a quiet room, decent microphone, and the willingness to re-record when you stumble over a line. Hiring voice talent costs $50 to $200 per video and adds days to your production timeline. Cloud TTS services like ElevenLabs or Play.ht solve the quality problem but introduce monthly bills that eat into ad revenue, especially when you are publishing 8 to 12 videos per month.

There is a better approach for Mac users: generate voiceovers locally, with no subscription, no upload, and no per-minute billing.

Script to Voiceover in Minutes

The workflow is simple. Write your script (or paste it from your doc), choose a voice, adjust the speed, and hit generate. Murmur produces a WAV file that you drag directly into your video editor. The entire process takes a few minutes for a typical 10-minute video script.

Speed control matters for YouTube. Educational content works best at 1.0x to 1.1x, giving viewers time to absorb information. Dramatic or storytelling content benefits from 0.9x, where pauses feel intentional. Fast-paced commentary or list videos can push to 1.2x without sounding rushed. You can preview different speeds before committing to a full generation.

Choosing the right voice for your channel is an underrated decision. Your voice becomes your brand. Viewers associate it with your content, and switching voices mid-series is jarring. Murmur's 860+ voice library lets you audition options before committing. Once you pick one, every video sounds consistent.

Will Viewers Notice It Is AI?

This is the question everyone asks. The honest answer: some will, most will not. YouTube audiences have grown accustomed to AI voices. Channels with millions of subscribers use them openly. The threshold is not "does it sound perfectly human" but "does it sound good enough that viewers stay and watch." In 2026, local TTS models clear that bar comfortably for most content categories.

Context matters too. A tech tutorial with screen recordings and a clear AI voice is perfectly fine. A personal vlog where emotional authenticity matters, less so. Know your genre. Faceless educational, financial, and informational channels are the sweet spot for AI voiceover.

Free Cloud Tools vs. Paid Cloud vs. Murmur

Free cloud TTS tools exist, but they come with strings. Most add watermarks, limit generation length, or restrict commercial use. Google's TTS API is technically free at low volumes but sounds robotic. Free tiers from ElevenLabs and Play.ht cap you at a few thousand characters per month, not enough for even one video script.

Feature	Free Cloud TTS	Paid Cloud (ElevenLabs)	Murmur

If you are publishing regularly, the math favors a one-time purchase. Even the cheapest ElevenLabs plan ($5/month) costs $60/year. Their Starter plan at $5/month limits you to 30,000 characters, roughly one or two video scripts. Serious creators need the $22/month Creator plan at minimum, which totals $264/year. Murmur pays for itself in 2 to 3 months.

Batch Export and Workflow Tips

Write your full script first, then generate audio in one pass. Generating paragraph by paragraph creates inconsistent pacing.
Use voice cloning to create a unique channel voice that no other creator has. Record 10 seconds in a quiet room and let Murmur build a voice model from it.
Export as WAV for maximum quality in your editor. Convert to MP3 only for final distribution if needed.
Generate at 1.0x speed, then adjust playback speed in your video editor for finer control.
Keep a consistent voice across your entire channel. Switching voices between videos confuses returning viewers.

Frequently Asked Questions

Can I use AI-generated voiceovers commercially on YouTube?

Yes. Murmur's license permits commercial use of all generated audio. You own the output. There are no royalty fees or attribution requirements for the audio you generate.

Can I use different voices for different characters in one video?

Yes. Generate each character's lines separately with a different voice, then layer them in your video editor. This works well for explainer videos with a narrator and quoted sources, or for storytelling channels.

How does the quality compare to hiring a voice actor?

A skilled voice actor still delivers more nuanced performance, especially for emotional content. But for informational, educational, and list-style videos, AI voiceover is comparable in quality and dramatically faster and cheaper.

What file format does Murmur export?

Murmur exports WAV files at 24kHz. WAV is lossless and works with every major video editor including Final Cut Pro, DaVinci Resolve, Premiere Pro, and CapCut.

Do I need to disclose that I use AI voiceover?

YouTube's policies require disclosure of synthetic media in some contexts. Check YouTube's current creator guidelines for AI-generated content. Many successful channels disclose AI use in their descriptions without any negative impact on views.

Try Murmur - $49 one-time. No subscriptions, no cloud, no per-character fees.

Originally published at murmurtts.com

Murmur vs ElevenLabs: Why Creators Are Switching to Local TTS

Tarun yadav — Fri, 10 Apr 2026 07:22:56 +0000

A detailed comparison of Murmur and ElevenLabs for text-to-speech. Price, privacy, quality, and offline support: everything creators need to know before choosing a TTS tool.

The Cloud TTS Problem

ElevenLabs built an impressive product. Their voice quality set a new standard for AI-generated speech, and they deserve credit for pushing the field forward. But their business model has a fundamental tension with how most creators actually use text-to-speech.

The pricing starts at $5/month for a limited hobby tier and scales to $99/month for the Pro plan most serious creators need. That's $1,188 per year. And if you're on a team or need higher limits, you're looking at $330/month, nearly $4,000 annually. Every character you generate counts against your quota. Run out mid-project, and you're either waiting until next month or upgrading your plan.

Then there's the privacy question. Every word you type gets sent to ElevenLabs' servers for processing. For published blog posts, that might not matter. But creators also generate audio for unpublished drafts, client work, legal documents, medical content, and personal projects. All of that text passes through a third-party cloud before you hear a single word.

Cloud TTS also means cloud dependencies. No internet, no audio. Spotty cafe Wi-Fi, degraded experience. API outage, dead in the water. For creators who travel, work remotely, or simply value reliability, this is a real constraint.

How Murmur Is Different

Murmur takes a fundamentally different approach. Instead of renting access to a cloud model, you run the model on your own hardware. The Kokoro TTS engine (82 million parameters) runs directly on Apple Silicon using MLX, Apple's machine learning framework. Your text never leaves your Mac.

You pay $49 once. That's it. No monthly fees, no per-character billing, no usage caps. Generate ten narrations or ten thousand, the price doesn't change. There's no account dashboard tracking your remaining credits, no surprise overage charges, no annual renewal.

Because everything runs locally, Murmur works offline. On a plane, in a cabin, at a conference with overloaded Wi-Fi. It doesn't matter. Once the app is set up, you don't need the internet at all. Your text stays on your machine, your audio stays on your machine, and there's no third party in the loop.

Side-by-Side Comparison

Feature	Murmur	ElevenLabs

ElevenLabs has clear advantages in generation speed, language coverage, and cross-platform availability. If you need 30+ languages, work primarily on Windows or Linux, or require the fastest possible generation times, ElevenLabs is the better fit.

But if you're a creator on a Mac who values privacy, wants predictable costs, and generates audio regularly, Murmur's model makes more sense. You're trading some speed and language breadth for permanent ownership and zero recurring costs.

Audio Quality Comparison

The most common question we get: does Murmur actually sound good? Rather than making claims, here are samples generated with Murmur so you can judge for yourself. These are unedited outputs, no post-processing, no cherry-picking.

Each sample above was generated by a different AI model, all running locally inside Murmur. No cloud processing, no post-production. Qwen3 excels at natural narration, Fish Audio delivers studio-quality expressiveness, and Chatterbox adds emotional depth. You get all of them for $49.

The Math

Drag the slider to see how costs compare over 12 months based on your usage. ElevenLabs charges per character, so more audio means higher tiers. Murmur stays at $49 no matter what.

Who Should Switch?

Not everyone should switch. If you need 30+ languages, work on Windows, or depend on ElevenLabs' API for production workflows, stay where you are. The right tool depends on your specific needs.

But if the following sounds like you, Murmur is worth a serious look:

Audiobook authors and narrators who generate high volumes of audio and are tired of per-character billing eating into margins.
YouTubers and video creators who need voiceovers for explainers, tutorials, or channel content and want a faster workflow than cloud round-trips.
Podcasters who want to convert written content into spoken episodes without recording themselves or hiring voice talent.
Course creators and educators who turn lesson scripts, study guides, and documentation into audio modules for students.
Newsletter writers and bloggers who want to add audio versions of their posts without a monthly subscription.
Anyone who handles sensitive content (legal, medical, financial, or confidential client work) and can't afford to send text through third-party servers.

Frequently Asked Questions

Can Murmur match ElevenLabs' voice quality?

For most creator use cases like blog narration, video voiceovers, and course content, the quality is comparable. ElevenLabs has an edge in voice cloning fidelity and emotional range at the extremes, but Kokoro's 82M parameter model produces natural, expressive speech that works well for long-form content. Listen to the samples above and decide for yourself.

Does Murmur work completely offline?

Yes. After the initial setup (which downloads the Kokoro TTS model), Murmur runs entirely on your Mac with no internet connection required. Your text never touches a server.

How many voices does Murmur have?

Murmur ships with 860+ community voices spanning different genders, ages, accents, and styles. You can also clone your own voice from a 10-second recording.

What languages does Murmur support?

Murmur currently supports 9 languages: English, Spanish, French, German, Italian, Portuguese, Japanese, Chinese, and Korean. ElevenLabs supports 30+, so if you need broad multilingual coverage, that's a consideration.

Can I use Murmur on Windows or Linux?

Not currently. Murmur is a native macOS app that requires Apple Silicon (M1 or later). It uses Apple's MLX framework for hardware-accelerated inference, which is Mac-only.

Is there a money-back guarantee?

Yes. Murmur comes with a 7-day refund policy. If it doesn't work for your use case, you get your money back.

Try Murmur - $49 one-time. No subscriptions, no cloud, no per-character fees.

Originally published at murmurtts.com

Step-By-Step Guide to Stripe Payments in React

Tarun yadav — Sun, 28 Jun 2020 02:24:04 +0000

What We’ll Cover

Replace Checkout.js with Stripe.js
Removing the Checkout.js button
Adding required Stripe fields
Integration the form action with Stripe.js

When you first build a Stripe integration, the advantage of Checkout.js over Stripe.js is its ease of integration and speed to a working app. However, it does not allow adding any additional input fields. In many situations, you'll want to collect other values such as Quantity, a drop down of products, shipping address, etc, and submit it with the same form that collects payment details. Or perhaps, you really just want a uniform style with the rest of your app that doesn't require a modal dialog to popup. Stripe’s smaller frontend library, called Stripe.js, does not include any UI elements but has all of the client side API functionality of generating payment tokens. Customizing the payment form will require no changes to the backend functionality of your Node.js app, because the front end will still be generating the same payment token.

Brief Overview of Checkout.js Functionality

If you've never integrated Stripe before, or it's been a while since you've done it, let's review just what the purpose is of the front end portion of Stripe! Stripe is an API as a Service, so your first question may be, "Why on earth does an API require the use of a front-end JavaScript library?" Great question! As you can imagine, handling your users' credit card information online is a potentially risky business - which is exactly why there is a security standard that you must adhere to in order to accept payments online. The Payment Card Industry Digital Security Standards (or PCI DSS, commonly just referred to as PCI for short), explicitly prohibits direct storing of credit card numbers by merchants - unless you are up to the task of "protecting stored cardholder data." Stripe's ingenuity was to build a simple front end mechanism that collects the cardholder payment data on your behalf so that it never even touches your server - making PCI-DSS compliance much easier.

Checkout.js bundles the cardholder data collection mechanism with a beautiful and easy to integrate modal popup form that collects that payment details from the user. This is a fantastic option for putting together a very quick Stripe integration, but will not seamlessly flow with the rest of your user interface. This is where Stripe.js come into play. The API still offers JavaScript methods for sending the payment details directly to Stripe, and receiving a payment token to represent the payment.

Installing Stripe.js

The Stripe documentation lists provides a Script tag that loads Stripe.js with the latest version. It may be tempting to install the Script with Bower by running bower install --save stripe.js=https://js.stripe.com/v2/, but keep in mind doing this is not officially endorsed by Stripe. There is no mention as to how often they update the client side libraries, so something may break on you unexpectedly. So your first option is to simply load the library by placing the Stripe provided script tag in the HTML file that your React app is mounted in:

<html>
    <head>
               <script type="text/javascript" src="https://js.stripe.com/v2/"></script>
    </head>
    <body style="margin: 0px;">
        <div id="main"></div>
        <script src="react-bundle.js"></script>
    </body>
<html>

A much better option would be to dynamically load this script with ReactScriptLoader! Considering a React app is a Single Page App, there are likely huge chunks of your app that do not have a payment form. Why load Stripe.js for the entire page when we can simply load it for just the payment form component? Let's make an empty React component for our payment form and dynamically load Stripe.js (note, this method would work just as well for Checkout.js!):

var React = require('react');
var ReactScriptLoaderMixin = require('react-script-loader').ReactScriptLoaderMixin;

var PaymentForm = React.createClass({
  mixins: [ ReactScriptLoaderMixin ],

  getInitialState: function() {
    return {
      stripeLoading: true,
      stripeLoadingError: false
    };
  },

  getScriptURL: function() {
    return 'https://js.stripe.com/v2/';
  },

  onScriptLoaded: function() {
    if (!PaymentForm.getStripeToken) {

      // Put your publishable key here
      Stripe.setPublishableKey('pk_test_xxxx');
      this.setState({ stripeLoading: false, stripeLoadingError: false });
    }
  },

  onScriptError: function() {
    this.setState({ stripeLoading: false, stripeLoadingError: true });
  },

  render: function() {
    if (this.state.stripeLoading) {
      return <div>Loading</div>;
    }
    else if (this.state.stripeLoadingError) {
      return <div>Error</div>;
    }
    else {
      return <div>Loaded!</div>;
    }
  }
});

module.exports = PaymentForm;

The ReactScriptLoaderMixin begins loading the remote script, and upon successfully loading it, or reaching an error, will invoke one of two event listeners. Once the script is successfully loaded, we can set the public key for Stripe.js. This in turn, gives us a conditional in the render function for three states of loading, errored, or loaded! Note that this method can also be used to load Checkout.js.

Building the Form

Now we have a React component with Stripe.js loaded, let's start building the custom payment form. At minimum, we need to collect four values for Stripe to generate a payment token for us: credit card number, expiration month, expiration year, and the cvc.

var React = require('react');
var ReactScriptLoaderMixin = require('react-script-loader').ReactScriptLoaderMixin;

var PaymentForm = React.createClass({
  mixins: [ ReactScriptLoaderMixin ],

  getInitialState: function() {
    return {
      stripeLoading: true,
      stripeLoadingError: false,
      submitDisabled: false,
      paymentError: null,
      paymentComplete: false,
      token: null
    };
  },

  getScriptURL: function() {
    return 'https://js.stripe.com/v2/';
  },

  onScriptLoaded: function() {
    if (!PaymentForm.getStripeToken) {
      // Put your publishable key here
      Stripe.setPublishableKey('pk_test_xxxx');

      this.setState({ stripeLoading: false, stripeLoadingError: false });
    }
  },

  onScriptError: function() {
    this.setState({ stripeLoading: false, stripeLoadingError: true });
  },

  onSubmit: function(event) {
    var self = this;
    event.preventDefault();
    this.setState({ submitDisabled: true, paymentError: null });
    // send form here
    Stripe.createToken(event.target, function(status, response) {
      if (response.error) {
        self.setState({ paymentError: response.error.message, submitDisabled: false });
      }
      else {
        self.setState({ paymentComplete: true, submitDisabled: false, token: response.id });
        // make request to your server here!
      }
    });
  },

  render: function() {
    if (this.state.stripeLoading) {
      return <div>Loading</div>;
    }
    else if (this.state.stripeLoadingError) {
      return <div>Error</div>;
    }
    else if (this.state.paymentComplete) {
      return <div>Payment Complete!</div>;
    }
    else {
      return (<form onSubmit={this.onSubmit} >
        <span>{ this.state.paymentError }</span><br />
        <input type='text' data-stripe='number' placeholder='credit card number' /><br />
        <input type='text' data-stripe='exp-month' placeholder='expiration month' /><br />
        <input type='text' data-stripe='exp-year' placeholder='expiration year' /><br />
        <input type='text' data-stripe='cvc' placeholder='cvc' /><br />
        <input disabled={this.state.submitDisabled} type='submit' value='Purchase' />
      </form>);
    }
  }
});

module.exports = PaymentForm;

Once Stripe.js is loaded, our payment form component returns a form with the required input fields. We’ve added the required data-stripe attributes per the Stripe documentation. The form onSubmit event invokes a handler on our component which calls Stripe.createToken(). If an error is returned, we display that to our users by setting state.paymentError equal to the error message. Otherwise, we set the payment is complete with this.paymentComplete, and that is also the point where we would pass the token and required purchasing information to our server with a module such as superagent.

Beginners Guide To React Hooks : Getting Started With React Hooks🔥🔥

Tarun yadav — Sat, 23 May 2020 16:24:57 +0000

This is a beginners guide to react hooks. It will take time to go through this guide, so grab a cup of coffee or whatever you like.

What are Hooks?
What's wrong with classes?
React's State Hooks
What is this useState() syntax?
What does useState() give us?
Using Multiple State Hooks
React's Effect Hook
Running an Effect Hook only when something changes

1. What are Hooks?

Hooks are the new feature introduced in the React 16.8 version. It allows you to use state and other React features without writing a class. Hooks are the functions which "hook into" React state and lifecycle features from function components. It does not work inside classes.

Don't worry though, classes aren't being removed or discouraged. React's Developers being given more ways to code!

2. What's wrong with classes?

The React Hooks intro gives a good section on this: Check Docs

There are couple of problem with Classes

It’s hard to reuse stateful logic between components.

React doesn’t offer a way to “attach” reusable behavior to a component. With Hooks, you can extract stateful logic from a component so it can be tested independently and reused.
Hooks allow you to reuse stateful logic without changing your component hierarchy. This makes it easy to share Hooks among many components or with the community.

Classes confuse both people and machines

The gist is classes can sometimes be confusing and can be written any number of ways. Dive into somebody else's project and you could be in for a world of different syntax and style choices.
By allowing classes to be converted into smaller functional components, we can even further break out parts of our application into smaller and more focused components.

3. React's State Hooks

Hook state is the new way of declaring a state in React app. Hook uses useState() functional component for setting and retrieving state.

Let's say we have a component like this:

import React from 'react';

class Example extends React.Component {
  constructor(props) {
    super(props);
    this.state = {
      count: 0
    };
  }

  render() {
    return (
      <div>
        <p>You clicked {this.state.count} times</p>
        <button onClick={() => this.setState({ count: this.state.count + 1 })}>
          Click me
        </button>
      </div>
    );
  }
}

This component will count the click on button.

With React Hooks, we are able to condense that class into this functional component:

import React, { useState } from 'react';

function Example() {
  // Declare a new state variable, which we'll call "count"  const [count, setCount] = useState(0);
  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>
        Click me
      </button>
    </div>
  );
}

Notice how much easier the functional component would be for beginners just learning React.

4. What is this useState() syntax

import React, { useState } from 'react';

function Example() {
  // Declare a new state variable, which we'll call "count"  
  const [count, setCount] = useState(0);

What does calling useState do?
It declares a “state variable”. Our variable is called count but we could call it anything else, like state.

What do we pass to useState as an argument?
The only argument to the useState() Hook is the initial state. In Classes the state should be Object, but in Hooks it does not need to be Object. We can keep a number or a string if that’s all we need. In our example,0 is the initial state.

What Do Square Brackets Mean?

You might have noticed the square brackets when we declare a state variable:

  const [count, setCount] = useState(0);

This JavaScript syntax is called “array destructuring”. It means that we’re making two new variables count and setCount, where count is set to the first value returned by useState, and setCount is the second.

5. What does useState() give us?

useState gives us two variables and we can name our two variables whatever we want. Just know that:

The first variable is the value. Similar to this.state
The second variable is a function to update that value. Similar to this.setState

The final part to useState is the argument that we pass to it. The useState argument is the initial state value. In the case of our counter, we started at 0.

6. Using Multiple State Hooks

We can even use useState() multiple times in the same function.

function ExampleWithManyStates() {
  const [age, setAge] = useState(42);
  const [fruit, setFruit] = useState('banana');
  const [todos, setTodos] = useState([{ text: 'Learn Hooks' }]);

7. React's Effect Hook

The Effect Hook lets you perform side effects in function components. It does not use components lifecycle methods which are available in class components. In other words, Effects Hooks are equivalent to componentDidMount(), componentDidUpdate() and componentWillUnmount() lifecycle methods.

Side-effects are things you want your application to make like:

Fetching data
Manually changing the DOM (document title)
Setting up a subscription

Effects will run after every render, including the first render.

Let's compare a class to a functional component:

import React, { Component } from 'react';

class Example extends Component {
  componentDidMount() {
    console.log('this is componentDidMount!');
    document.title = 'changeTitle';
  }

  render() {
    return <div>stuff goes here</div>;
  }
}

When using the the Effect Hook, we use useEffect():

function Example() {
  useEffect(() => {
    console.log('this is useEffect ');
    document.title = 'changeTitle';
  });

  return <div>stuff goes here</div>;
}

8. Running an Effect Hook only when something changes

Since useEffect() runs every time a component renders, how do we get it to only run once, on mount? The Effect Hook can take a second argument, an array. It will look through the array and only run the effect if one of those values has changed.

componentDidMount: Runs once

// only run on mount. pass an empty array
useEffect(() => {
  // only runs once
}, []);

componentDidUpdate: Runs on changes

// only run if count changes
useEffect(
  () => {
    // run here if count changes
  },
  [count]
);

Now, you have some understanding of hooks and how they work. If you want to learn hooks in-depth, you should check the official docs by React's Developers.

Forem: Tarun yadav

AI Voiceover for YouTube: No Subscription Required

The Voiceover Problem for YouTube Creators

Script to Voiceover in Minutes

Will Viewers Notice It Is AI?

Free Cloud Tools vs. Paid Cloud vs. Murmur

Batch Export and Workflow Tips

Frequently Asked Questions

Murmur vs ElevenLabs: Why Creators Are Switching to Local TTS

The Cloud TTS Problem

How Murmur Is Different

Side-by-Side Comparison

Audio Quality Comparison

The Math

Who Should Switch?

Frequently Asked Questions

Step-By-Step Guide to Stripe Payments in React

What We’ll Cover

Brief Overview of Checkout.js Functionality

Installing Stripe.js

Building the Form

Beginners Guide To React Hooks : Getting Started With React Hooks🔥🔥

Table of Contents

1. What are Hooks?

2. What's wrong with classes?

It’s hard to reuse stateful logic between components.

Classes confuse both people and machines

3. React's State Hooks

4. What is this useState() syntax

What Do Square Brackets Mean?

5. What does useState() give us?

6. Using Multiple State Hooks

7. React's Effect Hook

8. Running an Effect Hook only when something changes

componentDidMount: Runs once

componentDidUpdate: Runs on changes

If it helps you to understand Hooks, please give like