Unofficial Twitter API

Authentication

API Key Authentication

All Twitter API endpoints require authentication via API key. Include your API key in the request header:

X-API-Key: your-api-key-here

Getting Your API Key

To get your API key:

Sign up for an account at tweetcore.dev/register
Choose a pricing plan that fits your needs
Go to your dashboard to generate API keys
Copy your API key and include it in all requests

Twitter API Endpoints

Get User Profile

GET

/api/twitter/profile/{username}

Retrieve detailed information about a Twitter user profile.

Parameters

username path • required

Twitter username without @ symbol

Code Examples

                        // Get user profile
const getProfile = async (username) => {
  try {
    const response = await fetch(`https://tweetcore.dev/api/twitter/profile/${username}`, {
      headers: {
        'X-API-Key': 'your-api-key-here'
      }
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    console.log('User profile:', data);
    return data;
  } catch (error) {
    console.error('Error fetching profile:', error);
  }
};

// Usage
getProfile('elonmusk');
                    

                        import requests

def get_profile(username, api_key):
    """Get user profile information"""
    url = f"https://tweetcore.dev/api/twitter/profile/{username}"
    headers = {
        "X-API-Key": api_key,
        "Content-Type": "application/json"
    }
    
    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error fetching profile: {e}")
        return None

# Usage
profile = get_profile("elonmusk", "your-api-key-here")
if profile:
    print(f"User: {profile['name']} (@{profile['username']})")
    print(f"Followers: {profile['followers']}")
                    

                        <?php

function getProfile($username, $apiKey) {
    $url = "https://tweetcore.dev/api/twitter/profile/$username";
    $headers = [
        'X-API-Key: ' . $apiKey,
        'Content-Type: application/json'
    ];
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode === 200) {
        return json_decode($response, true);
    }
    return null;
}

// Usage
$profile = getProfile('elonmusk', 'your-api-key-here');
if ($profile) {
    echo "User: " . $profile['name'] . " (@" . $profile['username'] . ")\n";
}

?>
                    

                        curl -X GET "https://tweetcore.dev/api/twitter/profile/elonmusk" \
  -H "X-API-Key: your-api-key-here" \
  -H "Content-Type: application/json"
                    

Example Response

{
  "id": "1234567890",
  "username": "johndoe",
  "name": "John Doe",
  "bio": "Software developer and tech enthusiast",
  "followers": 1523,
  "following": 342,
  "tweets": 5672,
  "verified": false,
  "created_at": "2015-03-21T12:00:00Z",
  "profile_image": "https://pbs.twimg.com/profile_images/...",
  "banner_image": "https://pbs.twimg.com/profile_banners/..."
}

Get User Tweets

GET

/api/twitter/user/{username}/tweets

Retrieve recent tweets from a specific user by username.

Parameters

username path • required

Twitter username without @ symbol

count query • optional

Number of tweets to return (default: 20, max varies by plan)

cursor query • optional

Pagination cursor for getting more tweets

Code Examples

                        // Get user tweets
const getTweets = async (username, count = 20, cursor = null) => {
  try {
    let url = `https://tweetcore.dev/api/twitter/user/${username}/tweets?count=${count}`;
    if (cursor) url += `&cursor=${cursor}`;
    
    const response = await fetch(url, {
      headers: {
        'X-API-Key': 'your-api-key-here'
      }
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    console.log(`Found ${data.count} tweets`);
    return data;
  } catch (error) {
    console.error('Error fetching tweets:', error);
  }
};

// Usage
getTweets('elonmusk', 10);
                    

                        import requests

def get_tweets(username, api_key, count=20, cursor=None):
    """Get user tweets"""
    url = f"https://tweetcore.dev/api/twitter/user/{username}/tweets"
    params = {"count": count}
    if cursor:
        params["cursor"] = cursor
        
    headers = {
        "X-API-Key": api_key,
        "Content-Type": "application/json"
    }
    
    try:
        response = requests.get(url, headers=headers, params=params)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error fetching tweets: {e}")
        return None

# Usage
tweets = get_tweets("elonmusk", "your-api-key-here", count=10)
if tweets:
    print(f"Found {tweets['count']} tweets")
    for tweet in tweets['tweets']:
        print(f"- {tweet['text'][:100]}...")
                    

                        <?php

function getTweets($username, $apiKey, $count = 20, $cursor = null) {
    $url = "https://tweetcore.dev/api/twitter/user/$username/tweets";
    $params = ['count' => $count];
    if ($cursor) {
        $params['cursor'] = $cursor;
    }
    $url .= '?' . http_build_query($params);
    
    $headers = [
        'X-API-Key: ' . $apiKey,
        'Content-Type: application/json'
    ];
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode === 200) {
        return json_decode($response, true);
    }
    return null;
}

// Usage
$tweets = getTweets('elonmusk', 'your-api-key-here', 10);
if ($tweets) {
    echo "Found " . $tweets['count'] . " tweets\n";
}

?>
                    

                        curl -X GET "https://tweetcore.dev/api/twitter/user/elonmusk/tweets?count=10" \
  -H "X-API-Key: your-api-key-here" \
  -H "Content-Type: application/json"
                    

Example Response

{
  "username": "elonmusk",
  "user_id": "44196397",
  "tweets": [
    {
      "id": "1623456789012345678",
      "text": "Just launched my new project! Check it out...",
      "created_at": "2024-01-15T14:30:00Z",
      "likes": 42,
      "retweets": 12,
      "replies": 5,
      "media": [],
      "entities": {
        "hashtags": ["launch", "project"],
        "mentions": [],
        "urls": ["https://example.com"]
      }
    }
  ],
  "count": 10,
  "next_cursor": "DAABCgABF__",
  "has_more": true
}

Get Tweet Details

GET

/api/twitter/tweet/{tweet_id}

Retrieve detailed information about a specific tweet.

Parameters

tweet_id path • required

Unique identifier of the tweet

Code Examples

                        // Get tweet details
const getTweetDetails = async (tweetId) => {
  try {
    const response = await fetch(`https://tweetcore.dev/api/twitter/tweet/${tweetId}`, {
      headers: {
        'X-API-Key': 'your-api-key-here'
      }
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    console.log('Tweet details:', data);
    return data;
  } catch (error) {
    console.error('Error fetching tweet:', error);
  }
};

// Usage
getTweetDetails('1623456789012345678');
                    

                        import requests

def get_tweet_details(tweet_id, api_key):
    """Get details of a specific tweet"""
    url = f"https://tweetcore.dev/api/twitter/tweet/{tweet_id}"
    headers = {
        "X-API-Key": api_key,
        "Content-Type": "application/json"
    }
    
    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error fetching tweet: {e}")
        return None

# Usage
tweet = get_tweet_details("1623456789012345678", "your-api-key-here")
if tweet:
    print(f"Tweet: {tweet['text']}")
    print(f"Likes: {tweet.get('stats', {}).get('likes', 0)}")
                    

                        <?php

function getTweetDetails($tweetId, $apiKey) {
    $url = "https://tweetcore.dev/api/twitter/tweet/$tweetId";
    $headers = [
        'X-API-Key: ' . $apiKey,
        'Content-Type: application/json'
    ];
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode === 200) {
        return json_decode($response, true);
    }
    return null;
}

// Usage
$tweet = getTweetDetails('1623456789012345678', 'your-api-key-here');
if ($tweet) {
    echo "Tweet: " . $tweet['text'] . "\n";
}

?>
                    

                        curl -X GET "https://tweetcore.dev/api/twitter/tweet/1623456789012345678" \
  -H "X-API-Key: your-api-key-here" \
  -H "Content-Type: application/json"
                    

Example Response

{
  "id": "1623456789012345678",
  "text": "Just launched my new project! Check it out...",
  "created_at": "2024-01-15T14:30:00Z",
  "author": {
    "id": "1234567890",
    "username": "johndoe",
    "name": "John Doe",
    "verified": false
  },
  "stats": {
    "likes": 42,
    "retweets": 12,
    "replies": 5,
    "quotes": 2,
    "bookmarks": 8
  },
  "media": [],
  "thread": {
    "is_thread": false,
    "thread_id": null
  }
}

Get Tweet Conversation Details

GET

/api/twitter/tweet/{tweet_id}/details

Get full conversation details for a tweet including the main tweet and all replies in chronological order. Uses secure cursor-based pagination for efficient browsing through large conversation threads.

Parameters

tweet_id path • required

Unique identifier of the tweet to get conversation for

count query • optional

Number of tweets to return (default: 20, max varies by plan)

cursor query • optional

Secure pagination cursor token for getting more tweets in the conversation

Code Examples

                        // Get tweet conversation with pagination
const getConversation = async (tweetId, count = 20, cursor = null) => {
  try {
    let url = `https://tweetcore.dev/api/twitter/tweet/${tweetId}/details?count=${count}`;
    if (cursor) url += `&cursor=${cursor}`;
    
    const response = await fetch(url, {
      headers: {
        'X-API-Key': 'your-api-key-here'
      }
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    console.log(`Found ${data.count} tweets in conversation`);
    console.log(`Main tweet: ${data.main_tweet?.text}`);
    console.log(`Total replies: ${data.tweets.length - 1}`);
    
    // Check if more pages available
    if (data.has_more) {
      console.log(`Next cursor: ${data.next_cursor}`);
    }
    
    return data;
  } catch (error) {
    console.error('Error fetching conversation:', error);
  }
};

// Usage - get first page
getConversation('1935903191784390903', 5);

// Usage - get next page with cursor
getConversation('1935903191784390903', 5, 'KEynpesc-bpn9sIxILhlAR_ntipGQYxeJu7eKHt8Jq4');
                    

                        import requests

def get_conversation(tweet_id, api_key, count=20, cursor=None):
    """Get tweet conversation with pagination"""
    url = f"https://tweetcore.dev/api/twitter/tweet/{tweet_id}/details"
    params = {"count": count}
    if cursor:
        params["cursor"] = cursor
        
    headers = {
        "X-API-Key": api_key,
        "Content-Type": "application/json"
    }
    
    try:
        response = requests.get(url, headers=headers, params=params)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error fetching conversation: {e}")
        return None

# Usage - get first page
conversation = get_conversation("1935903191784390903", "your-api-key-here", count=5)
if conversation:
    print(f"Found {conversation['count']} tweets in conversation")
    print(f"Main tweet: {conversation['main_tweet']['text']}")
    
    # Get next page if available
    if conversation['has_more']:
        next_page = get_conversation(
            "1935903191784390903", 
            "your-api-key-here", 
            count=5, 
            cursor=conversation['next_cursor']
        )
        if next_page:
            print(f"Next page has {len(next_page['tweets'])} more tweets")
                    

                        <?php

function getConversation($tweetId, $apiKey, $count = 20, $cursor = null) {
    $url = "https://tweetcore.dev/api/twitter/tweet/$tweetId/details";
    $params = ['count' => $count];
    if ($cursor) {
        $params['cursor'] = $cursor;
    }
    $url .= '?' . http_build_query($params);
    
    $headers = [
        'X-API-Key: ' . $apiKey,
        'Content-Type: application/json'
    ];
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode === 200) {
        return json_decode($response, true);
    }
    return null;
}

// Usage - get first page
$conversation = getConversation('1935903191784390903', 'your-api-key-here', 5);
if ($conversation) {
    echo "Found " . $conversation['count'] . " tweets in conversation\n";
    echo "Main tweet: " . $conversation['main_tweet']['text'] . "\n";
    
    // Get next page if available
    if ($conversation['has_more']) {
        $nextPage = getConversation(
            '1935903191784390903', 
            'your-api-key-here', 
            5, 
            $conversation['next_cursor']
        );
        if ($nextPage) {
            echo "Next page has " . count($nextPage['tweets']) . " more tweets\n";
        }
    }
}

?>
                    

                        # Get first page of conversation
curl -X GET "https://tweetcore.dev/api/twitter/tweet/1935903191784390903/details?count=5" \
  -H "X-API-Key: your-api-key-here" \
  -H "Content-Type: application/json"

# Get next page using cursor from previous response
curl -X GET "https://tweetcore.dev/api/twitter/tweet/1935903191784390903/details?count=5&cursor=KEynpesc-bpn9sIxILhlAR_ntipGQYxeJu7eKHt8Jq4" \
  -H "X-API-Key: your-api-key-here" \
  -H "Content-Type: application/json"
                    

Example Response

{
  "tweet_id": "1935903191784390903",
  "tweets": [
    {
      "id": "1935903191784390903",
      "text": "Incredible Japan 🇯🇵🧵 Thread about Japanese innovation...",
      "created_at": "2024-12-17T06:20:45Z",
      "author": {
        "id": "44196397",
        "username": "elonmusk",
        "name": "Elon Musk",
        "verified": true
      },
      "stats": {
        "likes": 25420,
        "retweets": 8340,
        "replies": 1250,
        "quotes": 892
      },
      "media": [],
      "is_main_tweet": true
    },
    {
      "id": "1935904123456789012",
      "text": "Amazing thread! Thanks for sharing this perspective on Japan.",
      "created_at": "2024-12-17T06:25:12Z",
      "author": {
        "id": "123456789",
        "username": "tech_enthusiast",
        "name": "Tech Enthusiast",
        "verified": false
      },
      "stats": {
        "likes": 245,
        "retweets": 12,
        "replies": 5,
        "quotes": 2
      },
      "media": [],
      "is_main_tweet": false,
      "reply_to": "1935903191784390903"
    }
  ],
  "count": 5,
  "total_found": 1250,
  "next_cursor": "KEynpesc-bpn9sIxILhlAR_ntipGQYxeJu7eKHt8Jq4",
  "has_more": true,
  "main_tweet": {
    "id": "1935903191784390903",
    "text": "Incredible Japan 🇯🇵🧵 Thread about Japanese innovation...",
    "author": {
      "username": "elonmusk",
      "name": "Elon Musk"
    }
  },
  "endpoint_used": "conversation_details"
}

🔒 Secure Pagination

This endpoint uses secure cursor-based pagination with randomly generated 43-character tokens stored in the database. Each cursor is tied to your API key and the specific tweet conversation, preventing manipulation and ensuring consistent results. Cursors expire after 24 hours for security.

Search Tweets

GET

/api/twitter/search/tweets

Search for tweets matching specified criteria.

Parameters

q query • required

Search query (supports keywords, hashtags, mentions)

limit query • optional

Number of results to return (default: 10, max: 100)

Code Examples

                        // Search tweets
const searchTweets = async (query, limit = 10) => {
  try {
    const response = await fetch(`https://tweetcore.dev/api/twitter/search/tweets?q=${encodeURIComponent(query)}&limit=${limit}`, {
      headers: {
        'X-API-Key': 'your-api-key-here'
      }
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    console.log(`Found ${data.count} tweets for "${query}"`);
    return data;
  } catch (error) {
    console.error('Error searching tweets:', error);
  }
};

// Usage
searchTweets('bitcoin', 5);
                    

                        import requests
import urllib.parse

def search_tweets(query, api_key, limit=10):
    """Search for tweets"""
    url = "https://tweetcore.dev/api/twitter/search/tweets"
    params = {
        "q": query,
        "limit": limit
    }
    headers = {
        "X-API-Key": api_key,
        "Content-Type": "application/json"
    }
    
    try:
        response = requests.get(url, headers=headers, params=params)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error searching tweets: {e}")
        return None

# Usage
results = search_tweets("bitcoin", "your-api-key-here", limit=5)
if results:
    print(f"Found {results['count']} tweets for '{results['query']}'")
    for tweet in results['results']:
        print(f"- {tweet['text']}")
                    

                        <?php

function searchTweets($query, $apiKey, $limit = 10) {
    $url = "https://tweetcore.dev/api/twitter/search/tweets";
    $params = [
        'q' => $query,
        'limit' => $limit
    ];
    $url .= '?' . http_build_query($params);
    
    $headers = [
        'X-API-Key: ' . $apiKey,
        'Content-Type: application/json'
    ];
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode === 200) {
        return json_decode($response, true);
    }
    return null;
}

// Usage
$results = searchTweets('bitcoin', 'your-api-key-here', 5);
if ($results) {
    echo "Found " . $results['count'] . " tweets\n";
}

?>
                    

                        curl -X GET "https://tweetcore.dev/api/twitter/search/tweets?q=bitcoin&limit=5" \
  -H "X-API-Key: your-api-key-here" \
  -H "Content-Type: application/json"
                    

Example Response

{
  "query": "bitcoin",
  "results": [
    {
      "id": "search_tweet_0",
      "text": "Tweet containing 'bitcoin' - result #1",
      "author": {
        "username": "user_0",
        "name": "User 0"
      },
      "created_at": "2024-01-01T00:00:00Z",
      "likes_count": 50,
      "retweets_count": 25
    }
  ],
  "count": 10
}

Embed System

About Embed System

The embed system allows you to create public Twitter timeline embeds without exposing your API keys. Perfect for websites, blogs, and applications that need to display Twitter content to end users.

How it works: Generate embed tokens using your API key, then use those tokens in public URLs that don't require authentication.

Create Embed Token

POST

/api/twitter/embed/tokens

Generate a secure embed token for public Twitter timeline embedding.

Request Body

{
  "domain": "mywebsite.com",           // Optional: restrict to domain
  "username": "elonmusk",              // Optional: restrict to user
  "max_requests_per_day": 1000         // Daily usage limit
}

Example Response

{
  "embed_token": "ABC123DEF456GHI789JKL012MNO345PQR678STU901VWX234YZ",
  "domain": "mywebsite.com",
  "username": "elonmusk",
  "max_requests_per_day": 1000,
  "created_at": "2024-01-15T10:00:00Z",
  "usage_instructions": {
    "embed_url": "/api/twitter/embed/ABC123.../{username}/tweets",
    "iframe_example": "<iframe src=\"/api/twitter/embed/ABC123.../elonmusk/tweets?count=10\" width=\"600\" height=\"800\"></iframe>"
  }
}

List Embed Tokens

GET

/api/twitter/embed/tokens

List all active embed tokens for your account with usage statistics.

Example Response

{
  "embed_tokens": [
    {
      "token": "ABC123DEF456...",       // Truncated for security
      "domain": "mywebsite.com",
      "username": "elonmusk",
      "max_requests_per_day": 1000,
      "usage_count": 245,
      "last_used": "2024-01-15T14:30:00Z",
      "created_at": "2024-01-15T10:00:00Z"
    }
  ],
  "total": 1
}

Public Embed Endpoint

GET

/api/twitter/embed/{embed_token}/{username}/tweets

Public endpoint that returns HTML Twitter timeline without requiring API key authentication. Perfect for iframe embedding on websites.

Parameters

embed_token path • required

Your generated embed token

username path • required

Twitter username without @ symbol

count query • optional

Number of tweets to show (default: 10, max: 20)

iframe query • optional

Optimize for iframe embedding (default: true)

Usage Examples

Direct URL Access:

https://tweetcore.dev/api/twitter/embed/ABC123.../elonmusk/tweets?count=15

Iframe Embed:

<iframe 
  src="https://tweetcore.dev/api/twitter/embed/ABC123.../elonmusk/tweets?count=10" 
  width="600" 
  height="800" 
  frameborder="0"
  style="border-radius: 12px;">
</iframe>

Security & Usage Controls

Domain Restrictions

Limit embed tokens to specific domains to prevent unauthorized usage.

Username Restrictions

Optionally restrict tokens to specific Twitter usernames only.

Rate Limiting

Set daily request limits per embed token to control usage.

Usage Analytics

Track embed usage with detailed analytics and referer information.

User Management

Create API Key

POST

/api/users/api-keys

Generate a new API key for the authenticated user.

Request Body

{
  "name": "Production API Key",
  "description": "Key for production environment"
}

Example Response

{
  "id": 1,
  "key": "sk_live_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6",
  "name": "Production API Key",
  "description": "Key for production environment",
  "created_at": "2024-01-15T10:00:00Z",
  "last_used": null,
  "is_active": true
}

Get User Statistics

GET

/api/users/stats

Get usage statistics for the authenticated user.

Example Response

{
  "total_requests": 15234,
  "monthly_requests": 3421,
  "request_limit": 10000,
  "remaining_requests": 6579,
  "reset_date": "2024-02-01T00:00:00Z",
  "plan": {
    "name": "Pro",
    "price": 29,
    "rate_limit": 5
  }
}

Rate Limits

Rate Limit Headers

All API responses include rate limit information in the headers:

X-RateLimit-Limit

Maximum requests per second for your plan

X-RateLimit-Remaining

Remaining requests in current window

X-RateLimit-Reset

Unix timestamp when the rate limit window resets

X-Monthly-Limit

Total monthly request limit for your plan

X-Monthly-Remaining

Remaining monthly requests

Note: Exceeding rate limits will result in a 429 Too Many Requests response. Your requests will be automatically throttled based on your plan's limits.

Error Handling

Error Response Format

All errors follow a consistent format:

{
  "error": {
    "code": "RATE_LIMIT_EXCEEDED",
    "message": "Too many requests. Please retry after 60 seconds.",
    "details": {
      "retry_after": 60,
      "limit": 5,
      "window": "1s"
    }
  }
}

Common Error Codes

400 Bad Request - Invalid parameters

401 Unauthorized - Invalid or missing API key

403 Forbidden - Access denied

404 Not Found - Resource not found

429 Too Many Requests - Rate limit exceeded

500 Internal Server Error - Something went wrong

Code Examples

Python Example

import requests

API_KEY = "your-api-key-here"
BASE_URL = "https://tweetcore.dev"

headers = {
    "X-API-Key": API_KEY,
    "Content-Type": "application/json"
}

# Get user profile
response = requests.get(
    f"{BASE_URL}/api/twitter/profile/elonmusk",
    headers=headers
)

if response.status_code == 200:
    profile = response.json()
    print(f"Followers: {profile['followers']}")
else:
    print(f"Error: {response.status_code}")

JavaScript Example

const API_KEY = 'your-api-key-here';
const BASE_URL = 'https://tweetcore.dev';

async function getUserProfile(username) {
    try {
        const response = await fetch(
            `${BASE_URL}/api/twitter/profile/${username}`,
            {
                headers: {
                    'X-API-Key': API_KEY,
                    'Content-Type': 'application/json'
                }
            }
        );
        
        if (!response.ok) {
            throw new Error(`Error: ${response.status}`);
        }
        
        const profile = await response.json();
        console.log(`Followers: ${profile.followers}`);
    } catch (error) {
        console.error('Failed to fetch profile:', error);
    }
}

getUserProfile('elonmusk');

cURL Example

curl -X GET "https://tweetcore.dev/api/twitter/profile/elonmusk" \
  -H "X-API-Key: your-api-key-here" \
  -H "Content-Type: application/json"

Twitter API Documentation

Quick Navigation

Authentication

API Key Authentication

Getting Your API Key

Twitter API Endpoints

Get User Profile

Parameters

Code Examples

Example Response

Get User Tweets

Parameters

Code Examples

Example Response

Get Tweet Details

Parameters

Code Examples

Example Response

Get Tweet Conversation Details

Parameters

Code Examples

Example Response

🔒 Secure Pagination

Search Tweets

Parameters

Code Examples

Example Response

Embed System

About Embed System

Create Embed Token

Request Body

Example Response

List Embed Tokens

Example Response

Public Embed Endpoint

Parameters

Usage Examples

Direct URL Access:

Iframe Embed:

Security & Usage Controls

User Management

Create API Key

Request Body

Example Response

Get User Statistics

Example Response

Rate Limits

Rate Limit Headers

Error Handling

Error Response Format

Common Error Codes

Code Examples

Python Example

JavaScript Example

cURL Example

Need Help?