Shows
Title, author, category, language and links
Each show has a cover and an optional light-theme cover, a language (English, Arabic or French), an explicit flag, RSS owner details, Apple, Spotify and YouTube addresses and its own search settings.
Pods — by MrZaKaRiA IT Solutions
Pods: a podcast platform that runs on your own site
Pods is a podcast platform that lives inside your own website and admin. Publish shows and episodes with an RSS feed that carries the Apple Podcasts and Spotify tags, play them in one player that keeps going while visitors browse, and turn an article or a story into a two-voice episode with AI. You read and edit the script before a single word is spoken.
SCROLL
2 voices
A host and a guest, each with a voice you choose. Gemini speaks both in one take; OpenAI and Groq voice each turn.
7 script writers
Claude, OpenAI, Gemini, Groq, Hugging Face, NVIDIA NIM or a local Ollama, with a fallback order if one fails.
6 playback speeds
0.75x to 2x, 15-second skips, and the player remembers where each listener stopped.
0 listener accounts
No sign-in and no cookie. Resume spot and speed stay on the listener’s device; an IP address is stored only as a hash.
/ 07
A podcast section, built into your site.
Everything below ships in the one install, next to your pages, blog and admin.
- Shows & episodes
- AI script writer
- Two-voice speech
- ffmpeg audio join
- RSS feed
- Chapters
- Scheduled publishing
- Site-wide player
- Listen to this article
- Listen statistics
- Arabic & right-to-left
- Transcripts
- Installable site
- Structured data
Write
From an article to a script you can read before anything is spoken
Start from pasted text (at least 100 characters), a published blog post or a published story. The writer is told to use only what the source says and not to invent facts, numbers, quotes or names. You pick the tone, the language, the names of the two speakers and a target length from 1 to 30 minutes. The result lands in the episode’s Script tab as plain “Speaker: line” text. Nothing is spoken, and no speech credit is spent, until you press Generate audio.
- Four tones: conversational, educational, interview, storytelling
- Script in English, Arabic or French, with a host and a guest
- Edit any line, then generate the audio as a separate step
- A “Create podcast” action on every blog post and story that has no episode yet
Speak
Two voices, three speech providers, one MP3
Voices come from Google Gemini (30 voices, both speakers in one take), OpenAI (13 voices) or Groq Orpheus (6 English and 6 Arabic voices, each turn spoken separately). The parts are joined by ffmpeg into one MP3 at 128 kbit/s, mono, 44.1 kHz, and ffprobe reads the length. ffmpeg is checked before any paid request is made, and the temporary working folder is always deleted afterwards.
- Pick a voice for each of the two speakers
- Audio and length are read automatically after an upload too (mp3, m4a or wav up to 200 MB)
- Or point an episode at an audio file that lives elsewhere
- Optional “publish when the audio is ready”
Listen
One player for the whole site
A single audio element is created once for the entire site, so the docked mini player keeps playing while a visitor moves from page to page. It shows the cover, the title, the current chapter, back and forward 15 seconds, a scrubber and the speed. Lock-screen and headphone controls work through the browser’s Media Session, and the last position of every episode is remembered on that device.
- Six speeds: 0.75x, 1x, 1.25x, 1.5x, 1.75x, 2x
- Click a chapter to play from there
- Space to play and pause, arrow keys to skip
- Arabic and other right-to-left text is laid out right to left
Publish
An RSS feed with the Apple and Spotify tags, and pages search engines understand
Each show has its own feed at a stable address. It is RSS 2.0 with the iTunes tags, show notes as content, an enclosure with its size and type, and the episode, season and duration fields. The show page lists the feed and, wherever you have typed their addresses, buttons for Apple Podcasts, Spotify and YouTube. Episodes can be scheduled: set a go-live time and the scheduler publishes it on the minute. Pages carry PodcastSeries and PodcastEpisode structured data.
- Drafts, scheduled and archived episodes never appear in the feed
- Category mapped to Apple’s own list, Technology if nothing matches
- Sitemap entries for shows and episodes, noindex respected
- A saved change refreshes the cached pages right away
Episodes
Draft, schedule, publish, archive
The episode list shows the cover, season and episode number, length, status, how it was made, the publish date and page visits for 30 days and in total. Filter by status, show, whether it came from an article, whether it has audio, or a date range. Duplicate an episode as a draft, with its chapters. Deleting an episode clears the link on its blog post or story.
Editor
Show notes, chapters, transcript and search settings on one form
A rich-text editor for show notes (headings, bold, italic, links, lists, quotes), an excerpt, a cover, chapters with a title and a start time, a transcript you can keep private or make public, and your own title, description, share image and noindex switch. Each episode can be explicit, not explicit, or follow its show.
Numbers
Plays per day and your five most played episodes
The player reports five events, each at most once per play: started, ten seconds actually listened, half way, 90 percent and finished. The dashboard charts plays started per day for 30 days and lists the five most played episodes with how many were finished. Listeners are not identified: the device id is a random value made in the browser, there is no cookie, and the IP address is stored only as a keyed hash.
What is inside
Everything a small podcast needs, in the system you already run.
Each card describes what the code does today. The limits are listed further down.
Episodes
Four statuses, seasons and numbers
Draft, scheduled, published or archived. Season 1 to 999, episode 1 to 9999, an excerpt, show notes, an optional transcript and chapters.
AI writer
A script from your own text
From pasted text, a published post or a published story, in four tones, with a host and a guest. The AI may use only what the source says.
Voices
Gemini, OpenAI or Groq
30, 13, or 6 English and 6 Arabic voices. Each provider has its own key, stored encrypted, falling back to the matching text key.
Audio
Joined by ffmpeg, measured by ffprobe
One MP3, 128 kbit/s mono, with the real length, size and type stored on the episode.
Feed
RSS 2.0 for the podcast apps
iTunes channel and item tags, show notes as content, enclosure length and type, and a stable guid that keeps an imported episode’s old id.
Player
Mini player, speeds, resume, chapters
One player for the site, 15-second skips, six speeds, chapters, keyboard keys and lock-screen controls.
Articles
Listen to this article
A player on blog posts and stories with a published episode, and a home page slider of the latest episodes.
Statistics
Five listen events
Started, ten seconds, half, 90 percent and finished, with a hashed IP, a device type and, when your CDN sends it, a country code.
Arabic
Right to left where the text is
Titles, excerpts, notes, chapters and transcripts switch to right-to-left for Arabic, Hebrew, Persian and Urdu, or when the script is detected.
Install
The site is an installable app
The site, and each section on its own domain, ships its own web app manifest, icons and launch screens, with an offline screen.
Search
Structured data and a sitemap
Show pages carry PodcastSeries data, episode pages add PodcastEpisode with duration, season and the source article.
Foundations
How Pods runs: your server, a queue for the slow jobs, and limits you can read.
Making a podcast takes minutes of AI and audio work. These are the rules that keep it safe to leave running.
A section of your own system
Pods is part of the same Laravel API and Next.js site as your pages and blog, managed in the Filament admin. Audio is stored on the site’s own disk.
Slow work runs on a queue
The script job may run for up to 5 minutes, the audio job for up to 30, once per episode at a time. A failure keeps the script and stores a message that never contains a key.
Keys encrypted, usage logged
Provider keys are stored encrypted and are not echoed in errors. Script calls count against your monthly request budget and are written to the AI usage log.
Generation limits per admin
Five generations a minute and thirty an hour per admin user. Listen events are limited to 60 a minute per address.
Under /podcasts or on its own host
Run it at your-site/podcasts, or on a host of its own such as pod.mrzakaria.com. Links, canonical URLs, sitemaps and the feed follow that choice.
Pages refresh when you save
Saving an episode refreshes the cached pages of its show, the podcasts page and the blog post or story it was made from.
Measured, and dated
What was counted, and when.
Counted in the code on 18 October 2026: 73 automated PHP tests cover the podcast API, the admin, the script writer, the speech jobs, the RSS feed and the importer. Tests that need ffmpeg are skipped on machines without it. There are no front-end test files for the player yet.
The screenshots on this page are our own shows: two Arabic shows with six episodes, counted in our local copy on 18 October 2026. Where a screen shows listen counts, they are those of that copy and not a claim about anyone’s audience.
What protects you
Your audio, your keys and your listeners’ privacy stay on your side.
Pods adds nothing between you and your audience except the AI providers you choose to switch on.
- The audio, the scripts and the statistics live in your own database and storage.
- Nothing is spoken, and no speech credit is spent, until you have read the script and pressed Generate audio.
- AI calls use your own provider keys. They are stored encrypted and counted against a monthly request budget you set.
- There are no listener accounts. The player keeps its state on the listener’s device only.
- An IP address is never stored as such: it is kept as a keyed hash, and unknown or unpublished episodes are ignored quietly.
- The public API never returns scripts, generation state or listen data, and a transcript only when you tick public.
Next step
Bring an article you would like to hear.
In the walkthrough we turn one of your posts into a script together, show you the review step, and tell you plainly which parts of Pods fit your language and your audio.
How an episode is made
From a source text to an episode in your feed, in six steps.
The review step is the one that matters: it is where you decide what gets spoken.
01
Choose the source
Paste text of at least 100 characters, or pick a published blog post or story.
02
Set the options
Podcast, tone, language, target length, host and guest names, and a voice for each.
03
Review the script
The writer produces a title, an excerpt, the turns and chapters. You edit the text as “Speaker: line”.
04
Generate the audio
A separate, confirmed step. The speech parts are joined into one MP3 and the real length is read.
05
Publish or schedule
Publish now, tick publish-when-ready, or set a go-live time and let the scheduler do it.
06
Listen and read the numbers
Listeners play it on the site or in a podcast app from the feed; the dashboard shows plays and finishes.
The catch, in our words
What Pods does not do today.
A topic alone is not enough: the writer needs at least 100 characters of source text and may not add facts to it. A script has exactly two speakers. There is no loudness levelling, silence trimming, intro or outro music or fades: the parts are joined as they are. There are no listener accounts, saved episodes, queue, autoplay, sleep timer, comments or downloads, and no offline listening. The site installs as an app through the browser’s own install option; there is no install button in the page.
The feed has the iTunes tags but not the Podcasting 2.0 namespace, so chapters and transcripts live on the website and not in the feed. The statistics are plays per day and the top five episodes; unique listeners are not counted, and the country code is stored when a CDN sends it but is not shown. The wizard has no per-run model picker: one provider order and one generation-model setting apply. Script languages are English, Arabic (Modern Standard) and French, with no dialects. ffmpeg and ffprobe must be installed where the queue runs.
FAQ
Pods: the questions people actually ask.
Short, specific answers taken from what the code does.
Pods is a podcast platform built into your own website and admin. You create shows and episodes, upload audio or generate it with AI from your own text, publish an RSS feed with the Apple Podcasts and Spotify tags, and visitors listen in one player that keeps playing while they browse.
2
Can it make a podcast from just a topic?
No. The script writer needs at least 100 characters of source text: pasted text, a published blog post or a published story. It is told to use only what that text says, so it does not add facts, numbers, quotes or names of its own.
3
Do I get to review the script?
Yes. The wizard only writes the script. It appears in the episode’s Script tab as plain “Speaker: line” text that you can edit. Generating the audio is a separate step that you confirm, so no speech credit is spent before you have read it.
4
Which AI providers does it use?
For scripts: Anthropic (Claude), OpenAI, Google AI Studio (Gemini), Groq, Hugging Face, NVIDIA NIM or a local Ollama, with an ordered fallback if one fails. For voices: Google Gemini, OpenAI or Groq. You supply your own keys, which are stored encrypted.
5
Does it work in Arabic?
Yes. Scripts can be written in English, Arabic (Modern Standard Arabic) or French, titles and notes switch to right-to-left, and our own shows are in Arabic. Groq offers six Arabic voices; there are no dialect options.
6
Can listeners subscribe in a podcast app?
Each show has an RSS 2.0 feed with the iTunes tags, an enclosure with its size and type, and the episode, season and duration fields. The show page lists the feed and buttons for Apple Podcasts, Spotify and YouTube wherever you have entered their addresses.
7
What do I need on the server?
A queue worker for the AI jobs, and ffmpeg and ffprobe, which join the audio and read its length. The installer warns you if they are missing.
8
What do you know about my listeners?
A random device id made in the browser, an IP address kept only as a keyed hash, a device type, and a country code when your CDN supplies one. There are no accounts and no cookie for this.
9
Can I move shows over from the original Pods app?
Yes. A command imports shows, episodes with their audio, chapters, covers and listen events from the original standalone app’s database and storage, and keeps the old addresses redirecting.
Start here
Your own podcast section, on your own server.
A walkthrough is a working session: your first script, the review step, the feed, and a straight answer on whether Pods fits what you publish.
