Skip to content


Subversion checkout URL

You can clone with
Download ZIP
A simple EventMachine-based library for consuming Twitter's Streaming API.
Fetching latest commit...
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.


Gem Version Build Status Dependency Status Code Climate Coverage Status

TweetStream provides simple Ruby access to Twitter's Streaming API.


gem install tweetstream


Using TweetStream is quite simple:

require 'tweetstream'

TweetStream.configure do |config|
  config.consumer_key       = 'abcdefghijklmnopqrstuvwxyz'
  config.consumer_secret    = '0123456789'
  config.oauth_token        = 'abcdefghijklmnopqrstuvwxyz'
  config.oauth_token_secret = '0123456789'
  config.auth_method        = :oauth

# This will pull a sample of all tweets based on
# your Twitter account's Streaming API role. do |status|
  # The status object is a special Hash with
  # method access to its keys.
  puts "#{status.text}"

You can also use it to track keywords or follow a given set of user ids:

# Use 'track' to track a list of single-word keywords'term1', 'term2') do |status|
  puts "#{status.text}"

# Use 'follow' to follow a group of user ids (integers, not screen names), 53235) do |status|
  puts "#{status.text}"

The methods available to TweetStream::Client are kept in parity with the methods available on the Streaming API wiki page.

Changes in 2.0

TweetStream 2.0 introduces a number of requested features and bug fixes. For the complete list refer to the changelog. Notable additions in 2.0 include:


OAuth is now the default authentication method. Both userstreams and Site Streams exclusively work with OAuth. TweetStream still supports Basic Auth, however it is no longer the default. If you are still using Basic Auth, you should plan to move to OAuth as soon as possible.

Site Stream Support

Site Streams are now fully supported, including the connection management functionality.

Compatability with the Twitter gem

TweetStream now emits objects from the Twitter gem instead of custom hashes. These objects are already defined in the twitter gem and are superior to the custom objects in the following ways:

  1. Object equivalence (#== returns true if #ids are the same).
  2. The #created_at method returns a Date instead of a String.
  3. Allows boolean methods to be called with a question mark (e.g. User#protected?)

Additionally, any new features that are added to objects in the twitter gem (e.g. identity map) will be automatically inherited by TweetStream.


We've replaced the underlying gem that connects to the streaming API. twitter-stream has been replaced with em-twitter. It offers functionality parity with twitter-stream while also supporting several new features.

Removal of on_interval callback

We have removed the on_interval callback. If you require interval-based timers, it is possible to run TweetStream inside an already running EventMachine reactor in which you can define EM::Timer or EM::PeriodicTimer for time-based operations: do
  client = do
    # do something on an interval

Additional Notes

The parser configuration method has been removed as MultiJson automatically detects existing parsers.

Using the Twitter Userstream

Using the Twitter userstream works similarly to regular streaming, except you use the userstream method.

# Use 'userstream' to get message from your stream
client =

client.userstream do |status|
  puts status.text

Using Twitter Site Streams

client =

client.sitestream(['115192457'], :followings => true) do |status|
  puts status.inspect

Once connected, you can control the Site Stream connection:

# add users to the stream

# remove users from the stream

# obtain a list of followings of users in the stream
client.control.friends_ids('115192457') do |friends|
  # do something

# obtain the current state of the stream do |info|
  # do something

Note that per Twitter's documentation, connection management features are not immediately available when connected

You also can use method hooks for both regular timeline statuses and direct messages.

client =

client.on_direct_message do |direct_message|
  puts "direct message"
  puts direct_message.text

client.on_timeline_status do |status|
  puts "timeline status"
  puts status.text



TweetStream supports OAuth and Basic Auth. TweetStream::Client now accepts a hash: => 'you', :password => 'pass')

Alternatively, you can configure TweetStream via the configure method:

TweetStream.configure do |config|
  config.consumer_key       = 'cVcIw5zoLFE2a4BdDsmmA'
  config.consumer_secret    = 'yYgVgvTT9uCFAi2IuscbYTCqwJZ1sdQxzISvLhNWUA'
  config.oauth_token        = '4618-H3gU7mjDQ7MtFkAwHhCqD91Cp4RqDTp1AKwGzpHGL3I'
  config.oauth_token_secret = 'xmc9kFgOXpMdQ590Tho2gV7fE71v5OmBrX8qPGh7Y'
  config.auth_method        = :oauth

If you are using Basic Auth:

TweetStream.configure do |config|
  config.username     = 'username'
  config.password     = 'password'
  config.auth_method  = :basic

TweetStream assumes OAuth by default. If you are using Basic Auth, it is recommended that you update your code to use OAuth as Twitter is likely to phase out Basic Auth support. Basic Auth is only available for public streams as User Stream and Site Stream functionality only support OAuth.

Parsing JSON

TweetStream supports swappable JSON backends via MultiJson. Simply require your preferred JSON parser and it will be used to parse responses.

Handling Deletes and Rate Limitations

Sometimes the Streaming API will send messages other than statuses. Specifically, it does so when a status is deleted or rate limitations have caused some tweets not to appear in the stream. To handle these, you can use the on_delete, on_limit and on_enhance_your_calm methods. Example:

@client =

@client.on_delete do |status_id, user_id|

@client.on_limit do |skip_count|
  # do something

@client.on_enhance_your_calm do
  # do something


The on_delete and on_limit methods can also be chained:{ |status_id, user_id|
}.on_limit { |skip_count|
  # do something
}.track('intridea') do |status|
  # do something with the status like normal

You can also provide :delete and/or :limit options when you make your method call:'intridea',
  :delete => proc{ |status_id, user_id| # do something },
  :limit  => proc{ |skip_count| # do something }
) do |status|
  # do something with the status like normal

Twitter recommends honoring deletions as quickly as possible, and you would likely be wise to integrate this functionality into your application.

Errors and Reconnecting

TweetStream uses EventMachine to connect to the Twitter Streaming API, and attempts to honor Twitter's guidelines in terms of automatic reconnection. When Twitter becomes unavailable, the block specified by you in on_error will be called. Note that this does not indicate something is actually wrong, just that Twitter is momentarily down. It could be for routine maintenance, etc. do |message|
  # Log your error message somewhere
end.track('term') do |status|
  # Do things when nothing's wrong

However, if the maximum number of reconnect attempts has been reached, TweetStream will raise a TweetStream::ReconnectError with information about the timeout and number of retries attempted.

On reconnect, the block specified by you in on_reconnect will be called: do |timeout, retries|
  # Do something with the reconnect
end.track('term') do |status|
  # Do things when nothing's wrong

Terminating a TweetStream

It is often the case that you will need to change the parameters of your track or follow tweet streams. In the case that you need to terminate a stream, you may add a second argument to your block that will yield the client itself:

# Stop after collecting 10 statuses
@statuses = [] do |status, client|
  @statuses << status
  client.stop if @statuses.size >= 10

When stop is called, TweetStream will return from the block the last successfully yielded status, allowing you to make note of it in your application as necessary.


It is also possible to create a daemonized script quite easily using the TweetStream library:

# The third argument is an optional process name'tracker').track('term1', 'term2') do |status|
  # do something in the background

If you put the above into a script and run the script with ruby scriptname.rb, you will see a list of daemonization commands such as start, stop, and run.

A frequent use case is to use TweetStream along with ActiveRecord to insert new statuses to a database. The library TweetStream uses the daemons gem for daemonization which forks a new process when the daemon is created. After forking, you'll need to reconnect to the database:

ENV["RAILS_ENV"] ||= "production"

root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
require File.join(root, "config", "environment")

daemon ='tracker', :log_output => true)
daemon.on_inited do
  ActiveRecord::Base.logger ='log/stream.log', 'w+'))
daemon.track('term1') do |tweet|

Proxy Support

TweetStream supports a configurable proxy:

TweetStream.configure do |config|
  config.proxy = { :uri => 'http://myproxy:8081' }

Your proxy will now be used for all connections.


To access the Twitter REST API, we recommend the Twitter gem.



Copyright (c) 2012-2013 Intridea, Inc. ( See LICENSE for details.

Something went wrong with that request. Please try again.