Daily Dispatch Fire Service and Firefighter News RSS Feed Guide

Available RSS Feeds

All Articles Feed

https://dailydispatch.com/feed/

Returns the 10 most recent articles across all states and topics.

State-Specific Feeds

Subscribe to individual state feeds for regional news coverage:

https://dailydispatch.com/tag/{STATE-NAME}/feed/

Examples:

https://dailydispatch.com/tag/arizona/feed/
https://dailydispatch.com/tag/california/feed/
https://dailydispatch.com/tag/texas/feed/
https://dailydispatch.com/tag/florida/feed/
https://dailydispatch.com/tag/new-york/feed/
https://dailydispatch.com/tag/washington/feed/
https://dailydispatch.com/tag/oregon/feed/
https://dailydispatch.com/tag/illinois/feed/

Category Feeds

Filter by content classification:

https://dailydispatch.com/category/{CATEGORY-NAME}/feed/

Available Categories:

https://dailydispatch.com/category/news/feed/

Topic Feeds

Subscribe to specific content types and topics:

https://dailydispatch.com/tag/{TOPIC}/feed/

Available Topics:

https://dailydispatch.com/tag/columns/feed/
https://dailydispatch.com/tag/reader-commentary/feed/
https://dailydispatch.com/tag/national-event/feed/
https://dailydispatch.com/tag/announcements/feed/

RSS Feed Formats

Multiple syndication formats are supported for maximum compatibility:

Example Atom Feed:

https://dailydispatch.com/tag/arizona/feed/atom/

Using RSS Feeds in News Aggregators

Popular RSS Readers & News Aggregators

Web-Based:

• Feedly - Industry-leading feed reader with AI-powered features
• Inoreader - Advanced filtering and automation rules
• NewsBlur - Social features and custom filtering
• Feedbin - Clean interface with newsletter integration
• The Old Reader - Google Reader alternative

Desktop Applications:

• NetNewsWire (Mac/iOS) - Free, native, open-source
• Reeder (Mac/iOS) - Premium reader with iCloud sync
• FeedReader (Windows) - Desktop RSS client
• QuiteRSS (Cross-platform) - Open-source feed reader

News Organization Tools:

• Zapier - Automate RSS to Slack, email, databases
• IFTTT - Create RSS-based workflows
• RSS.app - Convert feeds to JSON, email digests
• FeedPress - Analytics and feed optimization

Setting Up Multi-State Monitoring

In Feedly:

1. Create a new folder called "West Coast Fire News"
2. Add feeds for California, Oregon, Washington
3. View all three states in one unified stream

In Inoreader:

1. Subscribe to multiple state feeds
2. Create a "Bundle" to group related feeds
3. Set up rules to filter or tag specific keywords

In NetNewsWire:

1. Add each state feed individually
2. Organize into folders by region
3. Use Smart Feeds to filter by keywords

Code Examples for Programmatic Access

JavaScript / Node.js

async function fetchRSSFeed(state = null) {
  const url = state 
    ? `https://dailydispatch.com/tag/${state}/feed/`
    : `https://dailydispatch.com/feed/`;
  
  const response = await fetch(url);
  const xml = await response.text();
  
  const parser = new DOMParser();
  const doc = parser.parseFromString(xml, 'text/xml');
  
  const items = doc.querySelectorAll('item');
  const articles = [];
  
  items.forEach(item => {
    articles.push({
      title: item.querySelector('title').textContent,
      link: item.querySelector('link').textContent,
      pubDate: item.querySelector('pubDate').textContent,
      description: item.querySelector('description').textContent
    });
  });
  
  return articles;
}

// Fetch Arizona fire news
fetchRSSFeed('arizona').then(articles => {
  console.log(`Found ${articles.length} articles`);
  articles.forEach(article => {
    console.log(`${article.title} - ${article.link}`);
  });
});

Python

import feedparser

# Parse Daily Dispatch RSS feed
feed = feedparser.parse('https://dailydispatch.com/tag/arizona/feed/')

print(f"Feed: {feed.feed.title}")
print(f"Articles: {len(feed.entries)}\n")

for entry in feed.entries:
    print(f"Title: {entry.title}")
    print(f"Link: {entry.link}")
    print(f"Published: {entry.published}")
    print(f"Description: {entry.summary[:100]}...")
    print("---\n")

Install feedparser:

pip install feedparser

Node.js (with rss-parser)

const Parser = require('rss-parser');
const parser = new Parser();

async function fetchMultipleStates(states) {
  const feeds = await Promise.all(
    states.map(state => 
      parser.parseURL(`https://dailydispatch.com/tag/${state}/feed/`)
    )
  );
  
  const allArticles = [];
  feeds.forEach(feed => {
    feed.items.forEach(item => {
      allArticles.push({
        title: item.title,
        link: item.link,
        pubDate: new Date(item.pubDate),
        state: item.categories?.[0] || 'unknown'
      });
    });
  });
  
  // Sort by date descending
  allArticles.sort((a, b) => b.pubDate - a.pubDate);
  
  return allArticles;
}

// Aggregate news from multiple states
fetchMultipleStates(['california', 'oregon', 'washington'])
  .then(articles => {
    console.log(`Total articles: ${articles.length}`);
    articles.slice(0, 10).forEach(article => {
      console.log(`[${article.state}] ${article.title}`);
    });
  });

Install rss-parser:

npm install rss-parser

PHP (for CMS integration)

<?php
// Fetch and parse RSS feed
$feed_url = 'https://dailydispatch.com/tag/arizona/feed/';
$xml = simplexml_load_file($feed_url);

echo "Feed: " . $xml->channel->title . "\n\n";

foreach ($xml->channel->item as $item) {
    echo "Title: " . $item->title . "\n";
    echo "Link: " . $item->link . "\n";
    echo "Date: " . $item->pubDate . "\n";
    echo "---\n";
}
?>

cURL (command line testing)

# Fetch RSS feed
curl https://dailydispatch.com/tag/arizona/feed/

# Pretty print with xmllint
curl -s https://dailydispatch.com/tag/arizona/feed/ | xmllint --format -

# Extract just titles
curl -s https://dailydispatch.com/tag/arizona/feed/ | \
  grep -oP '(?<=<title>).*?(?=</title>)' | \
  tail -n +2

Best Practices for News Aggregation

Polling Frequency

User-Agent Headers

Always identify your news organization when polling feeds:

User-Agent: YourNewsOrg/1.0 (https://yournewssite.com; [email protected])

Example with cURL:

curl -H "User-Agent: NewsAggregator/1.0 (https://example.com; [email protected])" \
  https://dailydispatch.com/feed/

Caching Strategy

For news aggregators:

• Cache feed XML for 15-30 minutes
• Store article permalinks to avoid duplicates
• Use conditional GET with If-Modified-Since headers
• Implement exponential backoff on errors

Example caching logic:

const CACHE_DURATION = 15 * 60 * 1000; // 15 minutes
const cache = new Map();

async function getCachedFeed(url) {
  const cached = cache.get(url);
  
  if (cached && Date.now() - cached.timestamp < CACHE_DURATION) {
    return cached.data;
  }
  
  const response = await fetch(url);
  const xml = await response.text();
  
  cache.set(url, {
    data: xml,
    timestamp: Date.now()
  });
  
  return xml;
}

Error Handling

async function fetchFeedWithRetry(url, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await fetch(url, {
        headers: {
          'User-Agent': 'NewsAggregator/1.0 ([email protected])'
        }
      });
      
      if (response.status === 429) {
        // Rate limited - wait and retry
        const retryAfter = response.headers.get('Retry-After') || 60;
        console.log(`Rate limited. Waiting ${retryAfter} seconds...`);
        await sleep(retryAfter * 1000);
        continue;
      }
      
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }
      
      return await response.text();
    } catch (error) {
      console.error(`Attempt ${i + 1} failed:`, error.message);
      
      if (i === maxRetries - 1) {
        throw error; // Final attempt failed
      }
      
      // Exponential backoff: 2s, 4s, 8s
      await sleep(Math.pow(2, i + 1) * 1000);
    }
  }
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

Common Use Cases

Regional News Dashboard

Aggregate fire news from multiple western states:

const westernStates = ['california', 'oregon', 'washington', 'nevada', 'arizona'];
const feeds = westernStates.map(state => 
  `https://dailydispatch.com/tag/${state}/feed/`
);

// Add all feeds to your aggregator
feeds.forEach(feed => {
  aggregator.subscribe(feed, {
    folder: 'Western States Fire News',
    pollInterval: 30 // minutes
  });
});

Email Digest Newsletter

Create a daily digest of fire news:

import feedparser
from datetime import datetime, timedelta

# Get posts from last 24 hours
yesterday = datetime.now() - timedelta(days=1)

feed = feedparser.parse('https://dailydispatch.com/feed/')
recent_posts = [
    entry for entry in feed.entries
    if datetime(*entry.published_parsed[:6]) > yesterday
]

# Generate email digest
for post in recent_posts:
    print(f"📰 {post.title}")
    print(f"🔗 {post.link}")
    print(f"📅 {post.published}\n")

Slack Integration

Post new articles to a Slack channel:

const Parser = require('rss-parser');
const parser = new Parser();
const { WebClient } = require('@slack/web-api');

const slack = new WebClient(process.env.SLACK_TOKEN);
let lastCheckTime = new Date();

setInterval(async () => {
  const feed = await parser.parseURL('https://dailydispatch.com/feed/');
  
  feed.items.forEach(async item => {
    const pubDate = new Date(item.pubDate);
    
    if (pubDate > lastCheckTime) {
      await slack.chat.postMessage({
        channel: '#fire-news',
        text: `🚒 *${item.title}*\n${item.link}`
      });
    }
  });
  
  lastCheckTime = new Date();
}, 15 * 60 * 1000); // Every 15 minutes

Database Archival

Archive all articles to a database for research:

import feedparser
import sqlite3
from datetime import datetime

# Connect to database
conn = sqlite3.connect('fire_news.db')
cursor = conn.cursor()

# Create table
cursor.execute('''
    CREATE TABLE IF NOT EXISTS articles (
        id INTEGER PRIMARY KEY,
        title TEXT,
        link TEXT UNIQUE,
        published TEXT,
        description TEXT,
        state TEXT
    )
''')

# Fetch and store all state feeds
states = ['arizona', 'california', 'texas', 'florida']

for state in states:
    feed_url = f'https://dailydispatch.com/tag/{state}/feed/'
    feed = feedparser.parse(feed_url)
    
    for entry in feed.entries:
        try:
            cursor.execute('''
                INSERT OR IGNORE INTO articles 
                (title, link, published, description, state)
                VALUES (?, ?, ?, ?, ?)
            ''', (
                entry.title,
                entry.link,
                entry.published,
                entry.summary,
                state
            ))
        except sqlite3.IntegrityError:
            pass  # Article already exists
    
    conn.commit()
    print(f"Archived {state} feed")

conn.close()

Troubleshooting

Feed Returns 404 Error

Common causes:

• State name spelling error (check lowercase and hyphens)
• Invalid tag or category name
• No content exists for that tag/category

Solution: Test the main feed first:

curl https://dailydispatch.com/feed/

Empty Feed or No Items

Possible reasons:

• No articles published recently for that state/topic
• Feed cache hasn't refreshed yet
• Tag has no associated content

Solution: Verify content exists by visiting the tag page directly:

https://dailydispatch.com/tag/arizona/

Rate Limiting (429 Error)

You're polling too frequently.

Solutions:

• Increase polling interval to 15+ minutes
• Implement exponential backoff
• Check Retry-After response header
• Cache feed responses locally

Malformed XML Errors

Feed won't parse correctly.

Solutions:

• Validate feed at W3C Feed Validator
• Check for special characters in titles/descriptions
• Use a robust XML parser that handles errors gracefully
• Report persistent issues to Daily Dispatch

Testing & Validation

Validate RSS Feeds

Use these free tools to ensure feeds are working correctly:

• W3C Feed Validator: https://validator.w3.org/feed/
• FeedValidator.org: https://www.feedvalidator.org/
• RSS Feed Checker: https://rssboard.org/rss-validator/

Simply paste any Daily Dispatch feed URL into these validators to check structure and compliance.

Test in RSS Readers

Before deploying to production, test feeds in actual RSS readers:

1. Subscribe to a state feed in Feedly or Inoreader
2. Verify articles appear correctly
3. Check that images and descriptions display properly
4. Confirm publication dates are accurate
5. Test feed updates by checking for new content

Command Line Testing

# Test feed accessibility
curl -I https://dailydispatch.com/tag/arizona/feed/

# Validate XML structure
curl -s https://dailydispatch.com/tag/arizona/feed/ | xmllint --noout -

# Count number of items
curl -s https://dailydispatch.com/feed/ | grep -c "<item>"

# Extract all article titles
curl -s https://dailydispatch.com/feed/ | \
  grep -oP '(?<=<title>).*?(?=</title>)' | \
  tail -n +2

Resources

RSS Specifications

• RSS 2.0 Specification: https://www.rssboard.org/rss-specification
• Atom Specification (RFC 4287): https://www.ietf.org/rfc/rfc4287.txt
• RSS Advisory Board: https://www.rssboard.org/

Tools & Libraries

• feedparser (Python): https://pypi.org/project/feedparser/
• rss-parser (Node.js): https://www.npmjs.com/package/rss-parser
• SimplePie (PHP): https://simplepie.org/
• Feed Validator: https://validator.w3.org/feed/

All articles:        https://dailydispatch.com/feed/
State feed:          https://dailydispatch.com/tag/{state}/feed/
Category feed:       https://dailydispatch.com/category/{category}/feed/
Topic feed:          https://dailydispatch.com/tag/{topic}/feed/

RSS 2.0:             /feed/
Atom:                /feed/atom/
RDF:                 /feed/rdf/

https://dailydispatch.com/tag/california/feed/
https://dailydispatch.com/tag/texas/feed/
https://dailydispatch.com/tag/florida/feed/
https://dailydispatch.com/tag/new-york/feed/

Advanced: REST API for Developers

For developers who prefer JSON over