feedparser

https://feedparser.readthedocs.io/en/latest/
Admin
feedparser is a Python library for downloading and parsing syndicated feeds across RSS, Atom, CDF,...
Tokens:44,024
Snippets:397
Trust Score:9.6
Update:1 month ago
Show doc for...
Tokens:
Raw
### Feed image example in XML and HTML

Source: https://feedparser.readthedocs.io/en/latest/reference-feed-image

The first block shows a feed image in RSS/XML format, and the second shows the equivalent HTML rendering. The XML example includes the image title, URL, link, width, height, and description. The HTML example wraps the image in an anchor and uses the same values for the src, width, height, alt, and title attributes.

```xml
<image>
<title>Feed logo</title>
<url>http://example.org/logo.png</url>
<link>http://example.org/</link>
<width>80</width>
<height>15</height>
<description>Visit my home page</description>
</image>

```

```html
<a href="http://example.org/">
<img src="http://example.org/logo.png"
width="80"
height="15"
alt="Feed logo"
title="Visit my home page">
</a>

```

--------------------------------

### Atom 0.3 feed example

Source: https://feedparser.readthedocs.io/en/latest/annotated-atom03

A complete Atom 0.3 feed example showing required and optional elements such as title, tagline, link, copyright, generator, id, modified, info, entry, author, contributor, summary, and content. Use this as a reference for parsing Atom 0.3 feeds with feedparser. Note that real-world feeds may omit any element, so parsed results may not contain all fields.

```xml
<?xml version="1.0" encoding="utf-8"?>
<feed version="0.3" xmlns="http://purl.org/atom/ns#" xml:base="http://example.org/" xml:lang="en">
  <title type="text/plain" mode="escaped">
    Sample Feed
  </title>
  <tagline type="text/html" mode="escaped">
    For documentation &lt;em&gt;only&lt;/em&gt;
  </tagline>
  <link rel="alternate" type="text/html" href="/"/>
  <copyright type="text/html" mode="escaped">
    &lt;p>Copyright 2004, Mark Pilgrim&lt;/p>&lt;
  </copyright>
  <generator url="http://example.org/generator/" version="3.0">
    Sample Toolkit
  </generator>
  <id>tag:feedparser.org,2004-04-20:/docs/examples/atom03.xml</id>
  <modified>2004-04-20T11:56:34Z</modified>
  <info type="application/xhtml+xml" mode="xml">
    <div xmlns="http://www.w3.org/1999/xhtml"><p>This is an Atom syndication feed.</p></div>
  </info>
  <entry>
    <title>First entry title</title>
    <link rel="alternate" type="text/html" href="/entry/3"/>
    <link rel="service.edit" type="application/atom+xml" title="Atom API entrypoint to edit this entry" href="/api/edit/3"/>
    <link rel="service.post" type="application/atom+xml" title="Atom API entrypoint to add comments to this entry" href="/api/comment/3"/>
    <id>tag:feedparser.org,2004-04-20:/docs/examples/atom03.xml:3</id>
    <created>2004-04-19T07:45:00Z</created>
    <issued>2004-04-20T00:23:47Z</issued>
    <modified>2004-04-20T11:56:34Z</modified>
    <author>
      <name>Mark Pilgrim</name>
      <url>http://diveintomark.org/</url>
      <email>mark@example.org</email>
    </author>
    <contributor>
      <name>Joe</name>
      <url>http://example.org/joe/</url>
      <email>joe@example.org</email>
    </contributor>
    <contributor>
      <name>Sam</name>
      <url>http://example.org/sam/</url>
      <email>sam@example.org</email>
    </contributor>
    <summary type="text/plain" mode="escaped">
      Watch out for nasty tricks
    </summary>
    <content type="application/xhtml+xml" mode="xml" xml:base="http://example.org/entry/3" xml:lang="en-US">
      <div xmlns="http://www.w3.org/1999/xhtml">Watch out for <span style="background-image: url(javascript:window.location='http://example.org/')"> nasty tricks</span></div>
    </content>
  </entry>
</feed>
```

--------------------------------

### Testing for element existence with Python dictionary idioms

Source: https://feedparser.readthedocs.io/en/latest/basic-existence

Use standard Python dictionary idioms to test for the presence of feed elements before accessing their values. The example checks membership with 'in' and uses the get() method with default values to handle missing elements safely.

```python
>>> import feedparser
>>> d = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/atom10.xml')
>>> 'title' in d.feed
True
>>> 'ttl' in d.feed
False
>>> d.feed.get('title', 'No title')
'Sample feed'
>>> d.feed.get('ttl', 60)
60
```

--------------------------------

### Parse a feed from a local file with feedparser.parse

Source: https://feedparser.readthedocs.io/en/latest/introduction

Use this snippet to parse a feed from a local file. The example assumes Windows and a file saved at c:\incoming\atom10.xml; use the path syntax appropriate for your platform.

```python
>>> import feedparser
>>> d = feedparser.parse(r'c:\incoming\atom10.xml')
>>> d['feed']['title']
'Sample Feed'

```

--------------------------------

### Accessing multiple links in an Atom entry

Source: https://feedparser.readthedocs.io/en/latest/uncommon-atom

Shows how to access the list of links for an Atom entry. The example parses an Atom feed and retrieves the first entry's links, demonstrating that each link is a dictionary with 'rel', 'type', 'href', and optionally 'length' keys.

```python
>>> import feedparser
>>> d = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/atom10.xml')
>>> e = d.entries[0]
>>> len(e.links)
4
>>> e.links[0]
{'rel': 'alternate',
'type': 'text/html',
'href': 'http://example.org/entry/3'}
>>> e.links[1]
{'rel': 'related',
'type': 'text/html',
'href': 'http://search.example.com/'}
>>> e.links[2]
{'rel': 'via',
'type': 'text/html',
'href': 'http://toby.example.com/examples/atom10'}
>>> e.links[3]
{'rel': 'enclosure',
'type': 'video/mpeg4',
'href': 'http://www.example.com/movie.mp4',
'length': '42301'}
```

--------------------------------

### Sample RSS 2.0 feed

Source: https://feedparser.readthedocs.io/en/latest/annotated-rss20

A complete RSS 2.0 feed example with channel and item elements. Note that real-world feeds may omit any element, so parsed results may not include all fields.

```xml
<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
  <channel>
    <title>Sample Feed</title>
    <description>For documentation &lt;em&gt;only&lt;/em&gt;</description>
    <link>http://example.org/</link>
    <language>en</language>
    <copyright>Copyright 2004, Mark Pilgrim</copyright>
    <managingEditor>editor@example.org</managingEditor>
    <webMaster>webmaster@example.org</webMaster>
    <pubDate>Sat, 07 Sep 2002 0:00:01 GMT</pubDate>
    <category>Examples</category>
    <generator>Sample Toolkit</generator>
    <docs>http://feedvalidator.org/docs/rss2.html</docs>
    <cloud domain="rpc.example.com" port="80" path="/RPC2" registerProcedure="pingMe" protocol="soap"/>
    <ttl>60</ttl>
    <image>
      <url>http://example.org/banner.png</url>
      <title>Example banner</title>
      <link>http://example.org/</link>
      <width>80</width>
      <height>15</height>
    </image>
    <textInput>
      <title>Search</title>
      <description>Search this site:</description>
      <name>q</name>
      <link>http://example.org/mt/mt-search.cgi</link>
    </textInput>
    <item>
      <title>First item title</title>
      <link>http://example.org/item/1</link>
      <description>Watch out for &lt;span style="background: url(javascript:window.location='http://example.org/')"&gt; nasty tricks&lt;/span&gt;</description>
      <author>mark@example.org</author>
      <category>Miscellaneous</category>
      <comments>http://example.org/comments/1</comments>
      <enclosure url="http://example.org/audio/demo.mp3" length="1069871" type="audio/mpeg"/>
      <guid>http://example.org/guid/1</guid>
      <pubDate>Thu, 05 Sep 2002 0:00:01 GMT</pubDate>
    </item>
  </channel>
</rss>
```

--------------------------------

### Basic authentication via URL credentials

Source: https://feedparser.readthedocs.io/en/latest/http-authentication

Embeds the username and password in the feed URL to access a basic-authentication-protected feed. The example uses username 'test' and password 'basic'.

```python
>>> import feedparser
>>> d = feedparser.parse('http://test:basic@feedparser.org/docs/examples/basic_auth.xml')
>>> d.feed.title
'Sample Feed'

```

--------------------------------

### Accessing contributors in an Atom feed

Source: https://feedparser.readthedocs.io/en/latest/uncommon-atom

Shows how to access the list of contributors for an Atom entry. The example parses an Atom feed and retrieves the first entry's contributors, demonstrating that each contributor is a dictionary with 'name', 'href', and 'email' keys.

```python
>>> import feedparser
>>> d = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/atom10.xml')
>>> e = d.entries[0]
>>> len(e.contributors)
2
>>> e.contributors[0]
{'name': 'Joe',
'href': 'http://example.org/joe/',
'email': 'joe@example.org'}
>>> e.contributors[1]
{'name': 'Sam',
'href': 'http://example.org/sam/',
'email': 'sam@example.org'}
```

--------------------------------

### Content-Location HTTP header

Source: https://feedparser.readthedocs.io/en/latest/resolving-relative-links

Demonstrates that when no root-level xml:base is specified, the default base URI is given by the Content-Location HTTP header. The example parses a feed with http_base.xml and shows resolved links.

```python
>>> import feedparser
>>> d = feedparser.parse("https://feedparser.readthedocs.io/en/latest/examples/http_base.xml")
>>> d.feed.link
'http://example.org/index.html'
>>> d.entries[0].link
'http://example.org/archives/000001.html'

```

--------------------------------

### Annotated RSS 2.0 feed with namespaces

Source: https://feedparser.readthedocs.io/en/latest/annotated-rss20-dc

A complete RSS 2.0 feed example using the dc, admin, content, and rdf namespaces. It includes channel metadata and one item with content:encoded. Note that real-world feeds may omit any element, so do not rely on any particular element being present in parsed results.

```XML
<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:admin="http://webns.net/mvcb/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<channel>
<title>Sample Feed</title>
<link>http://example.org/</link>
<description>For documentation only</description>
<dc:language>en-us</dc:language>
<dc:creator>Mark Pilgrim (mark@example.org)</dc:creator>
<dc:rights>Copyright 2004 Mark Pilgrim</dc:rights>
<dc:date>2004-06-04T17:40:33-05:00</dc:date>
<admin:generatorAgent rdf:resource="http://www.exampletoolkit.org/"/>
<admin:errorReportsTo rdf:resource="mailto:mark@example.org"/>
<item>
<title>First of all</title>
<link>http://example.org/archives/2002/09/04.html#first_of_all</link>
<guid isPermaLink="false">1983@example.org</guid>
<description>
Americans are fat. Smokers are stupid. People who don’t speak Perl are irrelevant.
</description>
<dc:subject>Quotes</dc:subject>
<dc:date>2002-09-04T13:54:20-05:00</dc:date>
<content:encoded><![CDATA[<cite>Ian Hickson</cite>: <q><a href="http://ln.hixie.ch/?start=1030823786&amp;count=1?">Americans are fat. Smokers are stupid. People who don’t speak Perl are irrelevant.</a></q> ]]>
</content:encoded>
</item>
</channel>
</rss>
```

--------------------------------

### feed.textinput annotated example: XML feed and HTML rendering

Source: https://feedparser.readthedocs.io/en/latest/reference-feed-textinput

The first block shows a feed's text input element with title, link, name, and description. The second block shows how that text input could be rendered as an HTML form, mapping the feed fields to form attributes and labels.

```xml
<textInput>
<title>Go!</title>
<link>http://example.org/search</link>
<name>keyword</name>
<description>Search this site:</description>
</textInput>

```

```html
<form method="get" action="http://example.org/search">
<label for="keyword">Search this site:</label>
<input type="text" id="keyword" name="keyword" value="">
<input type="submit" value="Go!">
</form>

```

--------------------------------

### Access HTTP response headers via d.headers

Source: https://feedparser.readthedocs.io/en/latest/http-other

After parsing a feed, the d.headers dictionary contains the HTTP response headers. The example shows the output for a sample feed, including date, server, etag, and content-type.

```python
>>> import feedparser
>>> d = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/atom03.xml')
>>> d.headers
{'date': 'Fri, 11 Jun 2004 23:57:50 GMT',
'server': 'Apache/2.0.49 (Debian GNU/Linux)',
'last-modified': 'Fri, 11 Jun 2004 23:00:34 GMT',
'etag': '"6c132-941-ad7e3080"',
'accept-ranges': 'bytes',
'vary': 'Accept-Encoding,User-Agent',
'content-encoding': 'gzip',
'content-length': '883',
'connection': 'close',
'content-type': 'application/xml'}

```

--------------------------------

### Using ETags to reduce bandwidth

Source: https://feedparser.readthedocs.io/en/latest/http-etag

Demonstrates how to capture an ETag from an initial request and pass it back in a subsequent request to check for feed updates.

```python
>>> import feedparser
>>> d = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/atom10.xml')
>>> d.etag
'"6c132-941-ad7e3080"'
>>> d2 = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/atom10.xml', etag=d.etag)
>>> d2.status
304
>>> d2.feed
{}
>>> d2.entries
[]
>>> d2.debug_message
'The feed has not changed since you last checked, so
the server sent no data.  This is a feature, not a bug!'
```

--------------------------------

### Accessing feed version with feedparser.parse

Source: https://feedparser.readthedocs.io/en/latest/version-detection

Use the version attribute of the parsed feed object to get the detected feed type and version. The examples show parsing various feed URLs and the corresponding version strings returned.

```python
>>> d = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/atom10.xml')
>>> d.version
'atom10'
>>> d = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/atom03.xml')
>>> d.version
'atom03'
>>> d = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/rss20.xml')
>>> d.version
'rss20'
>>> d = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/rss20dc.xml')
>>> d.version
'rss20'
>>> d = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/rss10.rdf')
>>> d.version
'rss10'
```

--------------------------------

### Send custom HTTP request headers with feedparser.parse

Source: https://feedparser.readthedocs.io/en/latest/http-other

Pass a dictionary of request headers to the request_headers parameter of feedparser.parse. The example sets Cache-control to max-age=0.

```python
import feedparser
d = feedparser.parse(
    'https://feedparser.readthedocs.io/en/latest/examples/atom03.xml',
    request_headers={'Cache-control': 'max-age=0'},
)

```

--------------------------------

### Accessing Common Entry Elements

Source: https://feedparser.readthedocs.io/en/latest/common-atom-elements

Demonstrates how to access entry-specific elements. Note that content is sanitized and returned as a list of dictionaries.

```python
>>> import feedparser
>>> d = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/atom10.xml')
>>> d.entries[0].title
'First entry title'
>>> d.entries[0].link
'http://example.org/entry/3
>>> d.entries[0].id
'tag:feedparser.org,2005-11-09:/docs/examples/atom10.xml:3'
>>> d.entries[0].published
'2005-11-09T00:23:47Z'
>>> d.entries[0].published_parsed
(2005, 11, 9, 0, 23, 47, 2, 313, 0)
>>> d.entries[0].updated
'2005-11-09T11:56:34Z'
>>> d.entries[0].updated_parsed
(2005, 11, 9, 11, 56, 34, 2, 313, 0)
>>> d.entries[0].summary
'Watch out for nasty tricks'
>>> d.entries[0].content
[{'type': 'application/xhtml+xml',
'base': 'http://example.org/entry/3',
'language': 'en-US',
'value': '<div>Watch out for <span>nasty tricks</span></div>'}]
```

--------------------------------

### xml:base and sibling attributes

Source: https://feedparser.readthedocs.io/en/latest/resolving-relative-links

Illustrates that xml:base affects other attributes in the element where it is declared. The example accesses links[1].rel and links[1].href, showing the resolved href.

```python
>>> import feedparser
>>> d = feedparser.parse("https://feedparser.readthedocs.io/en/latest/examples/base.xml")
>>> d.entries[0].links[1].rel
'service.edit'
>>> d.entries[0].links[1].href
'http://example.com/api/client/37'

```

--------------------------------

### xml:base on root-level element

Source: https://feedparser.readthedocs.io/en/latest/resolving-relative-links

Shows that an xml:base on the root element sets the base URI for all URIs in the feed. The example parses a feed and accesses feed.link and feed.generator_detail.href, which resolve to the base URI.

```python
>>> import feedparser
>>> d = feedparser.parse("https://feedparser.readthedocs.io/en/latest/examples/base.xml")
>>> d.feed.link
'http://example.org/index.html'
>>> d.feed.generator_detail.href
'http://example.org/generator/'

```

--------------------------------

### Using Last-Modified headers to reduce bandwidth

Source: https://feedparser.readthedocs.io/en/latest/http-etag

Demonstrates how to capture the Last-Modified date from an initial request and pass it back in a subsequent request to check for feed updates.

```python
>>> import feedparser
>>> d = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/atom10.xml')
>>> d.modified
Fri, 11 Jun 2012 23:00:34 GMT
>>> d.modified_parsed
(2004, 6, 11, 23, 0, 34, 4, 163, 0)
>>> d2 = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/atom10.xml', modified=d.modified)
>>> d2.status
304
>>> d2.feed
{}
>>> d2.entries
[]
>>> d2.debug_message
'The feed has not changed since you last checked, so
the server sent no data.  This is a feature, not a bug!'
```

--------------------------------

### Overriding xml:base on an <entry>

Source: https://feedparser.readthedocs.io/en/latest/resolving-relative-links

Demonstrates that an xml:base attribute on an <entry> overrides the xml:base on the parent <feed>. The example accesses entry link and author_detail.href, which resolve to the entry's base URI.

```python
>>> import feedparser
>>> d = feedparser.parse("https://feedparser.readthedocs.io/en/latest/examples/base.xml")
>>> d.entries[0].link
'http://example.org/archives/000001.html'
>>> d.entries[0].author_detail.href
'http://example.org/about/'

```

--------------------------------

### Atom 1.0 XML Feed Structure

Source: https://feedparser.readthedocs.io/en/latest/annotated-atom10

A complete example of an Atom 1.0 feed containing metadata, entry details, authors, contributors, and content. This structure serves as a reference for how feedparser maps XML elements.

```xml
<?xml version=”1.0” encoding=”utf-8”?> <feed xmlns=”http://www.w3.org/2005/Atom” xml:base=”http://example.org/” xml:lang=”en”> <title type=”text”> Sample Feed </title> <subtitle type=”html”> For documentation &lt;em&gt;only&lt;/em&gt; </subtitle> <link rel=”alternate” type=”html” href=”/”/> <link rel=”self” type=”application/atom+xml” href=”http://www.example.org/atom10.xml”/> <rights type=”html”> &lt;p>Copyright 2005, Mark Pilgrim&lt;/p> </rights> <generator uri=”http://example.org/generator/” version=”4.0”> Sample Toolkit </generator> <id>tag:feedparser.org,2005-11-09:/docs/examples/atom10.xml</id> <updated>2005-11-09T11:56:34Z</updated> <entry> <title>First entry title</title> <link rel=”alternate” href=”/entry/3”/> <link rel=”related” type=”text/html” href=”http://search.example.com/”/> <link rel=”via” type=”text/html” href=”http://toby.example.com/examples/atom10”/> <link rel=”enclosure” type=”video/mpeg4” href=”http://www.example.com/movie.mp4” length=”42301”/> <id>tag:feedparser.org,2005-11-09:/docs/examples/atom10.xml:3</id> <published>2005-11-09T00:23:47Z</published> <updated>2005-11-09T11:56:34Z</updated> <author> <name>Mark Pilgrim</name> <uri>http://diveintomark.org/</uri> <email>mark@example.org</email> </author> <contributor> <name>Joe</name> <url>http://example.org/joe/</url> <email>joe@example.org</email> </contributor> <contributor> <name>Sam</name> <url>http://example.org/sam/</url> <email>sam@example.org</email> </contributor> <summary type=”text”> Watch out for nasty tricks </summary> <content type=”xhtml” xml:base=”http://example.org/entry/3” xml:lang=”en-US”><div xmlns=”http://www.w3.org/1999/xhtml”>Watch out for <span style=”background-image: url(javascript:window.location=’http://example.org/’)”> nasty tricks</span></div> </content> </entry> </feed>
```

--------------------------------

### Accessing an Atom feed using RSS terminology

Source: https://feedparser.readthedocs.io/en/latest/content-normalization

Demonstrates how to parse an Atom feed and access its elements using standard RSS dictionary keys like 'channel' and 'items'.

```python
>>> import feedparser
>>> d = feedparser.parse('https://feedparser.readthedocs.io/en/latest/examples/atom10.xml')
>>> d['channel']['title']
'Sample Feed'
>>> d['channel']['link']
'http://example.org/'
>>> d['channel']['description']
'For documentation <em>only</em>
>>> len(d['items'])
1
>>> e = d['items'][0]
>>> e['title']
'First entry title'
>>> e['link']
'http://example.org/entry/3'
>>> e['description']
'Watch out for nasty tricks'
>>> e['author']
'Mark Pilgrim (mark@example.org)'
```
Tokens:
Raw