[https://github.com/imperatrona/twitter-scraper] Scrape the Twitter frontend API without authentication with Golang.
Find a file
2023-05-10 17:43:02 +03:00
.github/workflows Add creds for CI 2023-05-10 17:43:02 +03:00
.gitignore add scrap tweets for any search query feature 2020-05-14 14:59:33 +02:00
api.go Add GetCookies and SetCookies 2023-05-10 11:42:47 +03:00
api_test.go Separate test package 2021-12-07 10:18:01 +02:00
auth.go Add GetCookies and SetCookies 2023-05-10 11:42:47 +03:00
auth_test.go Add GetCookies and SetCookies 2023-05-10 11:42:47 +03:00
go.mod Update deps 2023-04-23 17:29:40 +03:00
go.sum Update deps 2023-04-23 17:29:40 +03:00
LICENSE Add MIT license 2020-02-11 14:40:05 +02:00
profile.go Deprecate default scraper 2022-05-04 11:55:12 +03:00
profile_test.go Fix TestGetProfilePrivate 2023-01-10 13:02:35 +02:00
README.md Add GetCookies and SetCookies 2023-05-10 11:42:47 +03:00
scraper.go don't replace existing client 2023-05-10 08:50:24 +03:00
search.go Fix latest search 2023-04-30 00:25:35 +03:00
search_test.go Add GetCookies and SetCookies 2023-05-10 11:42:47 +03:00
timeline.go Merge branch 'master' into user-name 2023-05-10 06:05:18 -07:00
trends.go Add authentication 2023-04-23 17:32:28 +03:00
trends_test.go Deprecate default scraper 2022-05-04 11:55:12 +03:00
tweets.go add fetch tweets by userID func 2023-05-10 06:09:11 -07:00
tweets_test.go Merge branch 'master' into user-name 2023-05-10 06:05:18 -07:00
types.go Merge branch 'master' into user-name 2023-05-10 06:05:18 -07:00
util.go Add GetCookies and SetCookies 2023-05-10 11:42:47 +03:00

Twitter Scraper

Go Reference

Twitter's API is annoying to work with, and has lots of limitations — luckily their frontend (JavaScript) has it's own API, which I reverse-engineered. No API rate limits. No tokens needed. No restrictions. Extremely fast.

You can use this library to get the text of any user's Tweets trivially.

Installation

go get -u github.com/n0madic/twitter-scraper

Usage

Get user tweets

package main

import (
    "context"
    "fmt"
    twitterscraper "github.com/n0madic/twitter-scraper"
)

func main() {
    scraper := twitterscraper.New()

    for tweet := range scraper.GetTweets(context.Background(), "Twitter", 50) {
        if tweet.Error != nil {
            panic(tweet.Error)
        }
        fmt.Println(tweet.Text)
    }
}

It appears you can ask for up to 50 tweets (limit ~3200 tweets).

Get single tweet

package main

import (
    "fmt"

    twitterscraper "github.com/n0madic/twitter-scraper"
)

func main() {
    scraper := twitterscraper.New()
    tweet, err := scraper.GetTweet("1328684389388185600")
    if err != nil {
        panic(err)
    }
    fmt.Println(tweet.Text)
}

Search tweets by query standard operators

Tweets containing “twitter” and “scraper” and “data“, filtering out retweets:

package main

import (
    "context"
    "fmt"
    twitterscraper "github.com/n0madic/twitter-scraper"
)

func main() {
    scraper := twitterscraper.New()
    for tweet := range scraper.SearchTweets(context.Background(),
        "twitter scraper data -filter:retweets", 50) {
        if tweet.Error != nil {
            panic(tweet.Error)
        }
        fmt.Println(tweet.Text)
    }
}

The search ends if we have 50 tweets.

See Rules and filtering for build standard queries.

Set search mode

scraper.SetSearchMode(twitterscraper.SearchLatest)

Options:

  • twitterscraper.SearchTop - default mode
  • twitterscraper.SearchLatest - live mode
  • twitterscraper.SearchPhotos - image mode
  • twitterscraper.SearchVideos - video mode
  • twitterscraper.SearchUsers - user mode

Get profile

package main

import (
    "fmt"
    twitterscraper "github.com/n0madic/twitter-scraper"
)

func main() {
    scraper := twitterscraper.New()
    profile, err := scraper.GetProfile("Twitter")
    if err != nil {
        panic(err)
    }
    fmt.Printf("%+v\n", profile)
}

Search profiles by query

package main

import (
    "context"
    "fmt"
    twitterscraper "github.com/n0madic/twitter-scraper"
)

func main() {
    scraper := twitterscraper.New().SetSearchMode(twitterscraper.SearchUsers)
    for profile := range scraper.SearchProfiles(context.Background(), "Twitter", 50) {
        if profile.Error != nil {
            panic(profile.Error)
        }
        fmt.Println(profile.Name)
    }
}
package main

import (
    "fmt"
    twitterscraper "github.com/n0madic/twitter-scraper"
)

func main() {
    scraper := twitterscraper.New()
    trends, err := scraper.GetTrends()
    if err != nil {
        panic(err)
    }
    fmt.Println(trends)
}

Use authentication

Some specified user tweets are protected that you must login and follow. It is also required to search.

err := scraper.Login("username", "password")

Status of login can be checked with:

scraper.IsLoggedIn()

Logout (clear session):

scraper.Logout()

If you want save session between restarts, you can save cookies with scraper.GetCookies() and restore with scraper.SetCookies().

For example, save cookies:

cookies := scraper.GetCookies()
// serialize to JSON
js, _ := json.Marshal(cookies)
// save to file
f, _ = os.Create("cookies.json")
f.Write(js)

and load cookies:

f, _ := os.Open("cookies.json")
// deserialize from JSON
var cookies []*http.Cookie
json.NewDecoder(f).Decode(&cookies)
// load cookies
scraper.SetCookies(cookies)
// check login status
scraper.IsLoggedIn()

Use Proxy

Support HTTP(s) and SOCKS5 proxy

with HTTP

err := scraper.SetProxy("http://localhost:3128")
if err != nil {
    panic(err)
}

with SOCKS5

err := scraper.SetProxy("socks5://localhost:1080")
if err != nil {
    panic(err)
}

Delay requests

Add delay between API requests (in seconds)

scraper.WithDelay(5)

Load timeline with tweet replies

scraper.WithReplies(true)