Account Activity API


Table of Contents

Part 1:

- Introduction
- Getting Started & Setting Up the Twitter App.
- Usage:
  - Stream Events in Real Time.
  - Configuration.
- Installation

Part 2:

- Deploying On Web Server
  - Code Snippet
  - Calling API From Local Machine.
  - How do you view account activity events in real-time?

Introduction

The Account Activity API is designed to get an accounts activity events in real time. It works differently than Twitter’s REST API or the Streaming API – as it sends the activity events through a webhook URL. Developers need to set a webhook URL, pass a Challenge Response Check (CRC) validation , register the callback URL , and finally subscribe to an account’s activity. All of this sounds overwhelming but twitivity does all the heavy lifting under the hood.

Features

  • Performs Challenge-Response Check validation.
  • Registers webhook URL.
  • Subscribes to current user’s context.
  • Receives Twitter Account Activity events in real-time.
  • List registered webhooks.
  • Delete webhooks

Getting Started#

  • Apply for a Twitter Developer Account
  • Create an application , fill in the required fields, the callback URL is your domain name with an added endpoint, for example https://yourdomain.com/webhook/twitter. Twitter will later use this URL to send you account activity data. Make sure to enable “Read, Write and Direct messages” permission.
  • Navigate to the Dev environment section and setup a dev environment for the Account Activity API. Name a dev environment label of your choosing and select your app.

The next step is to register your webhook URL. Twitter will send a GET request with Challenge-Response Check or CRC token to verify you are the owner of the app and the webhook URL. To validate, an encrypted response token based on your consumer key and the CRC token has to be sent back to Twitter. Upon successful validation, registration of the webhook URL and subscription. Twitter will send data to this endpoint (the webhook URL) as a POST request.

Usage#

Ngrok is a handy tool to try out the API locally, on your machine. Install and run ngrok and replace your app’s URL and callback URL with the link ngrok provides. Make sure to use the one with https.

~$ ./ngrok http 5000

Stream events in real time.#

# stream_events.py

>>> from twitivity import Event
>>> import json

>>> class StreamEvent(Event):
     CALLBACK_URL: str = "https://yourdomain.com/webhook/twitter"

     def on_data(self, data: json) -> None:
         # process data

>>> stream_events = StreamEvent()
>>> stream_events.listen()

Configuration#

The configuration below only has to be done once before running the application for the first time.

Store the credentials as environment variables.

App -> Details -> Keys and Tokens

~$ export consumer_key=API_KEY
~$ export consumer_secret=API_SECRET_KEY
~$ export access_token=ACCESS_TOKEN
~$ export access_token_secret=ACCESS_TOKEN_SECRET
~$ export env_name=ENV_NAME # this is the dev environment label name you choose.

Register & Subscribe

To register the webhook URL and subscribe to activities, run both programs in parallel (first stream_events.py then configure.py). This will register the webhook URL and subscribe to the user’s activities.

# configure.py
>>> from twitivity import Activity

>>> account_activity = Activity()
>>> account_activity.register_webhook(
    "https://youdomain.com/webhook/twitter"
  )
>>> account_activity.subscribe()

# Response
{
  'id': '1198870971131686912', # webhook id
  'url': 'https://yourdomain.com/webhook/twitter',
  'valid': True,
  'created_timestamp': '2019-11-25 07:48:08 +0000'
}

Installation#

~$ pip3 install twitivity

Deploying On Web Servers

Code Snippet#

Here’s a small code snippet you can use to deploy it in a web server.


# app.py

import flask
import json
import hmac
import os
import hashlib
import base64
import logging
import flask

logging.basicConfig(
    filename="app.log",
    filemode="w",
    level=logging.INFO,
)

app = flask.Flask(__name__)

os.environ["consumer_secret"] = f"{consumer_secret}"


@app.route("/webhook/twitter", methods=["GET", "POST"])
def callback() -> json:
    if flask.request.method == "GET"
      or flask.request.method == "PUT":
        hash_digest = hmac.digest(
            key=os.environ[
              "consumer_secret"].encode("utf-8"),
            msg=flask.request.args.get(
              "crc_token").encode("utf-8"),
            digest=hashlib.sha256,
        )
        return {
            "response_token": "sha256="
            + base64.b64encode(hash_digest).decode("ascii")
        }
    elif flask.request.method == "POST":
        data = flask.request.get_json()
        logging.info(data)
        return {"code": 200}

Calling API From Local Machine#

Once the code running on the server. You can register and subscribe to events from your local machine.

# activity.py

from pprint import pprint
from twitivity import Activity


if __name__ == '__main__':
    activity = Activity()
    pprint(activity.register_webhook(
        "https://domain.com/webhook/twitter"))
    pprint(activity.subscribe())

How do you view account activity events in real-time?#

From your server, execute the following command.

~$ tail -f app.log