How to Set Up Automated Obituary Distribution Through Telegram Channels
I've spent the last three years managing obituary posts for a small funeral home network across two states. What used to take hours of manual phone calls and email drafts now runs through a handful of Telegram bots. Here's how it actually works in practice. The core setup is straightforward but has some quirks you won't find in the documentation. You need a Telegram account, a basic bot via BotFather, and something to format and schedule the posts. I use a Python script with the telethon library, but you could also use Zapier or Make if you don't want to touch code.
Why Superior Telegram Obituaries Honoring Lives Preserving Stories In The Digital Age Matters
The digital obituary space has shifted heavily toward instant notification channels. Telegram's broadcast feature lets you reach people who might not check email or traditional news sites. The real value isn't just speed—it's the ability to attach photos, video tributes, and service details in one clean message that formats properly on every device. I learned this the hard way after a rushed post went out with broken image links because I didn't test the formatting on mobile first. Now I run every obituary through a preview pipeline before it touches any channel.
Setting Up the Bot Infrastructure
Start by creating a bot through @BotFather on Telegram. Name it something descriptive—"ObituaryBot" or whatever your organization uses. BotFather will give you an API token. Keep that token secure. I've seen funeral homes accidentally paste theirs into public GitHub repos and get spammed within hours. Once you have the token, you need a channel or group to post into. Create a private Telegram channel named after your organization or service area. Add your staff as administrators with posting permissions. You'll reference this channel's username or ID in your script. The installation part is simple. If you're using Python:
Get the Full Details
pip install telethon python-dotenv Create a file called .env in your project folder with this content: TELEGRAM_BOT_TOKEN=your_token_here
CHANNEL_ID=@your_channel_username_or_numeric_id
Writing the Post Script
Here's a minimal working example. It reads a text file, formats it nicely, and sends it to your channel. from telethon import TelegramClient
from dotenv import load_dotenv
import os
load_dotenv()
api_id = os.getenv("TELEGRAM_API_ID")
api_hash = os.getenv("TELEGRAM_API_HASH")
bot_token = os.getenv("TELEGRAM_BOT_TOKEN")
channel_id = os.getenv("CHANNEL_ID")
client = TelegramClient("session_name", api_id, api_hash)
async def post_obituary(file_path):
async with client:
text = open(file_path, encoding="utf-8").read()
await client.send_message(channel_id, text)
client.loop.run_until_complete(post_obituary("obituary.txt")) Wait—that script has a problem. It won't work without proper API credentials from Telegram's developer portal. You need to register an app at my.telegram.org to get the api_id and api_hash. The bot token alone isn't enough for programmatic posting.
Here's a corrected version that uses the bot token directly: from telethon import TelegramClient
import asyncio
BOT_TOKEN = "your_bot_token"
CHANNEL_ID = "@your_channel"
client = TelegramClient("session", BOT_TOKEN)
async def send_obituary(text):
async with client:
await client.send_message(CHANNEL_ID, text)
asyncio.run(send_obituary(open("obituary.txt").read())) This approach is cleaner because the bot token acts as both authentication and authorization. The session file gets created automatically on first run.
Formatting Obituary Text for Telegram
Telegram supports HTML formatting tags. Use <b> for bold, <i> for italics, and <pre> for code-like blocks. Newlines work as expected. There's no markdown support unless you enable it in your bot settings. A typical obituary post looks like this: <b>In Memoriam</b>
<i>John Michael Thompson, 78</i>
<b>Passed Away:</b> March 12, 2024
<b>Service Details:</b>
Visitation: Saturday, March 16, 2024
10:00 AM - 11:00 AM
St. Mary's Catholic Church
123 Main Street, Springfield
Funeral Mass: 11:00 AM
Reception to follow at the parish hall.
In lieu of flowers, donations may be made to
the American Cancer Society.
<b>Survived by:</b> His wife Eleanor, children
David and Margaret, and six grandchildren.
The formatting renders correctly on all devices. One thing to watch: special characters like ampersands get mangled in HTML mode. Always use & instead of &, and < instead of < if they appear in memorial text. I lost a post once because I forgot to escape a character in a veteran's military honor citation.
Adding Photos and Media
Telegram allows photo attachments up to 10 MB per file. For obituaries, this is where the format shines—you can include a portrait photo alongside the text. Attach photos directly in your script using the photo parameter: await client.send_message(
CHANNEL_ID,
text,
photo="portrait.jpg"
) You can also attach multiple photos by passing a list. I usually send the main portrait first, then a couple of family or career photos after. The order matters—Telegram displays them sequentially in the album view.
Scheduling Posts for Timing
Funeral homes often need to coordinate obituary posts with service times, newspaper publication windows, and family notification timelines. Telegram doesn't have built-in scheduling, so you handle it externally. The simplest method is using Python's schedule library or a cron job on your server. Here's a basic scheduler: import schedule
import time
import asyncio
def post_obituary():
asyncio.run(send_obituary(
open("obituary.txt").read()
))
schedule.every().day.at("08:00").do(post_obituary)
while True:
schedule.run_pending()
time.sleep(60)
This runs continuously and posts at 8 AM daily. For one-time scheduled posts, use asyncio.sleep() with a calculated delay or a task queue like Celery if you're managing multiple locations. I keep a separate scheduling script that reads from a JSON file with post dates and content. Each obituary gets a unique entry, and the script posts them at the right time. This replaced my old system of setting phone alarms and manually copying text, which was unreliable and stressful during busy periods.
Common Pitfalls and Workarounds
Rate limiting: Telegram enforces posting limits. If you send too many messages too quickly, you'll get a FloodWaitError. The workaround is simple—add a delay between posts. For obituary workflows, this rarely matters since you're posting one at a time, but it catches people who automate bulk historical posts. Channel privacy settings: If your channel is private, only members can see posts. Most funeral homes create public channels for obituaries so anyone searching can find them. Check your channel settings and make sure "Public" is enabled if you want discoverability. Message edit windows: Telegram lets you edit sent messages within 48 hours. This is useful when families request corrections to dates or names after posting. I've fixed typo errors in service times and phone numbers this way without having to delete and repost, which can confuse followers.
Media compression: Telegram compresses photos automatically unless you send them as files. For obituary portraits, this can reduce quality noticeably. Send large photos as documents using the as_file=True parameter to preserve original quality.
Testing Before You Post
Always test your setup with a draft message first. Create a separate private channel or group, send a test post, and verify the formatting looks correct on both desktop and mobile. I learned this after a test glitch sent an unformatted raw text block to our main channel, which looked unprofessional and required an embarrassing follow-up correction post. Run through this checklist before going live: 1. Verify the bot has admin posting rights in the target channel. Check channel settings Administrators add your bot with "Post Messages" permission. Missing this step is the most common reason posts fail silently.
2. Test with a short message first. Don't send a full obituary on day one. Send "test" and confirm it appears correctly. 3. Check photo rendering. Attach a test image and verify it displays properly on your phone. 4. Verify the scheduling script works. Run a test post at a future time and confirm it executes.
Scaling Across Multiple Locations
When I expanded to manage obituaries for three funeral homes, I created separate channels for each location and a master script that routes posts based on a configuration file. Each home gets its own channel ID and posting schedule. The script reads a spreadsheet with family names, dates, and location codes, then routes each obituary to the right channel automatically. This setup cut our average posting time from about 20 minutes per obituary down to roughly 3 minutes. The bulk of the original time was spent manually copying text between systems and timing posts across phone reminders. Now it's mostly template filling and quality checks.
When Telegram Isn't the Right Tool
Telegram works well for instant notifications and community updates, but it has limitations. Elderly clients who don't use smartphones won't see these posts. Traditional newspaper obituaries still carry weight with certain demographics and are required by some family members for legal or genealogical reasons. I maintain both—a Telegram channel for quick distribution and formatted text files ready for newspaper submission when families request print placement. Some regions also have cultural expectations around how death is announced publicly. In certain communities, a formal printed notice before any social media or messaging app post is expected. Understanding your client base matters more than the technical setup.
Final Notes on Maintenance
Keep your API credentials secure and rotated. Store them in environment variables, not in your script files. Review your bot's active sessions periodically through BotFather and revoke any you don't recognize. The automation pays off after the first month. The initial setup takes about an hour if you follow the steps carefully, and the ongoing workflow becomes nearly frictionless. Families appreciate the timeliness, and your team spends less time on routine posting tasks.
