# GETTR Scraper: Profiles, Posts, Timelines & Search (`thescrapelab/apify-gettr-scraper`) Actor

Scrape public GETTR profiles, user timelines, posts, search results, media URLs, author data, and engagement metrics with a fast Python API-first Apify Actor.

- **URL**: https://apify.com/thescrapelab/apify-gettr-scraper.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** Social media, Automation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### GETTR Scraper for Apify

Scrape public GETTR profiles, user timelines, posts, and search results with a fast Python Apify Actor. This GETTR scraper is built for OSINT research, social media monitoring, journalism, brand safety, disinformation analysis, and data engineering workflows that need structured GETTR data without running a browser.

The Actor uses GETTR's public web API endpoints with async HTTP requests. It is written strictly in Python with the official Apify Python SDK, `httpx`, Apify Proxy support, cursor pagination, retries, and standardized JSON output.

### What You Can Scrape

- GETTR user profiles by username or profile URL
- Public GETTR user timelines and posts
- Individual GETTR posts from post URLs
- Keyword and hashtag search results
- Profile search results when post search is unavailable for a term
- Images, videos, post stats, author details, and raw API fragments for auditability

### Why Use This GETTR Scraper

This Actor is designed for high-throughput API-first scraping. It avoids Playwright, Selenium, Node.js, TypeScript, and Cheerio, so runs are lighter, faster, and cheaper than browser automation for public GETTR data collection.

Use it when you need a GETTR API scraper, GETTR profile scraper, GETTR post scraper, GETTR timeline scraper, GETTR search scraper, or social media OSINT dataset that can run on Apify infrastructure with proxy rotation and structured dataset exports.

### Input

You can configure the Actor from Apify Console, API, CLI, scheduler, or integrations.

| Field | Type | Description |
| --- | --- | --- |
| `startUrls` | array of strings | GETTR profile, post, or search URLs. |
| `usernames` | array of strings | GETTR usernames, with or without `@`. |
| `searchTerms` | array of strings | Keywords or hashtags to search. |
| `maxItems` | integer | Maximum number of post/profile records to save. |
| `maxConcurrency` | integer | Advanced setting for maximum concurrent HTTP requests. |
| `includeRawData` | boolean | Advanced setting to include original GETTR API fragments. Disabled by default for clean exports. |
| `proxyConfiguration` | object | Advanced Apify Proxy or custom proxy settings. |

Example input:

```json
{
  "startUrls": [
    "https://gettr.com/user/support",
    "https://gettr.com/post/p2bipx0ac19"
  ],
  "usernames": ["support"],
  "searchTerms": ["trump", "#news"],
  "maxItems": 100,
  "maxConcurrency": 12,
  "includeRawData": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

At least one of `startUrls`, `usernames`, or `searchTerms` must be provided.

### Output

Results are saved to the default Apify Dataset. Each item has `type: "post"` or `type: "user"` and includes normalized fields for clean exports.
By default, output is clean and export-friendly. Enable `includeRawData` only when you need original GETTR API fragments for audit or advanced OSINT analysis.

Example post item:

```json
{
  "type": "post",
  "source": "user_timeline",
  "query": "support",
  "id": "p2bipx0ac19",
  "url": "https://gettr.com/post/p2bipx0ac19",
  "text": "Post text...",
  "createdAt": "2023-03-15T12:40:43.158000+00:00",
  "likeCount": 6298,
  "repostCount": 8455,
  "replyCount": 4830,
  "mediaUrls": ["https://media.gettr.com/group/example/image.jpg"],
  "authorUsername": "milesguo",
  "authorDisplayName": "MILES GUO"
}
```

Example user item:

```json
{
  "type": "user",
  "source": "profile",
  "query": "support",
  "id": "support",
  "username": "support",
  "displayName": "Support & Help",
  "bio": "GETTR Support (Official Account)",
  "followersCount": 4105269,
  "followingCount": 1,
  "profileImageUrl": "https://media.gettr.com/group/example/avatar.png",
  "isVerified": true
}
```

### Data Fields

Post records can include:

- Post ID and canonical GETTR URL
- Text content and detected language
- Created and updated timestamps
- Like, repost, reply, and view counts
- Media URLs for images and videos
- Link preview metadata
- Flat author fields for exports, including username, display name, profile image, follower count, following count, and verification status
- Optional raw event, post, stats, and user API fragments

User records can include:

- Username and user ID
- Display name and bio
- Location, website, and language
- Follower and following counts
- Verification status and badges
- Profile image and banner URLs
- Created and updated timestamps
- Optional raw user API fragment

### Proxy Configuration

The Actor supports Apify Proxy through the standard `proxyConfiguration` input. Automatic Apify Proxy selection is the safest default for most users. Residential proxies can help for larger GETTR scraping jobs, but the Apify account running the Actor must have access to the selected proxy group.

For high-volume scraping, keep `maxConcurrency` conservative and use Apify Proxy sessions to reduce rate-limit and blocking risk.

### How It Works

The scraper targets GETTR web API endpoints used by the public frontend, including profile lookup, user timeline pagination, post lookup, post search, and profile search. It handles cursor pagination, retries transient 429 and 5xx errors with exponential backoff, rotates user agents, and creates Apify proxy sessions per target.

No browser automation is used by default. This keeps the Actor efficient and production-friendly for public GETTR data extraction.

### Use Cases

- OSINT investigations involving public GETTR accounts
- Social media monitoring and trend tracking
- Political, media, and influence research
- Dataset creation for NLP, entity extraction, and network analysis
- Brand safety and reputation monitoring
- Archiving public GETTR posts and profile metadata

### Limitations

GETTR is an undocumented, changing web API. Some search endpoints may behave differently by term, region, proxy, or time. The Actor includes fallback logic, but endpoint changes can still affect results. Private content, logged-in-only data, and deleted posts are not scraped.

Always use this Actor responsibly and comply with applicable laws, platform terms, and privacy requirements.

### Local Development

Install dependencies and run with the Apify CLI:

```bash
pip install -r requirements.txt
apify run
```

Deploy to Apify:

```bash
apify push
```

# Actor input Schema

## `startUrls` (type: `array`):

Paste GETTR profile, post, or search URLs. You can also use the username and search term fields below instead.

## `usernames` (type: `array`):

GETTR usernames to scrape. The @ prefix is optional. The Actor collects the profile and public timeline posts.

## `searchTerms` (type: `array`):

Keywords or hashtags to search on GETTR. Use this for discovery and monitoring workflows.

## `maxItems` (type: `integer`):

Maximum number of users/posts to push to the dataset across all targets.

## `maxConcurrency` (type: `integer`):

Maximum number of concurrent HTTP requests. Keep the default unless you need to tune speed versus rate-limit risk.

## `includeRawData` (type: `boolean`):

Save original GETTR API fragments in each dataset item for auditability. Leave disabled for cleaner, smaller exports.

## `proxyConfiguration` (type: `object`):

Optional proxy settings. Automatic Apify Proxy works for most users; residential proxies can help for larger runs if your account has access.

## Actor input object example

```json
{
  "startUrls": [
    "https://gettr.com/user/support"
  ],
  "usernames": [
    "support"
  ],
  "searchTerms": [
    "trump"
  ],
  "maxItems": 100,
  "maxConcurrency": 12,
  "includeRawData": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Default dataset containing normalized GETTR post and user records.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://gettr.com/user/support"
    ],
    "usernames": [
        "support"
    ],
    "searchTerms": [
        "trump"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/apify-gettr-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": ["https://gettr.com/user/support"],
    "usernames": ["support"],
    "searchTerms": ["trump"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("thescrapelab/apify-gettr-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://gettr.com/user/support"
  ],
  "usernames": [
    "support"
  ],
  "searchTerms": [
    "trump"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call thescrapelab/apify-gettr-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=thescrapelab/apify-gettr-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GETTR Scraper: Profiles, Posts, Timelines & Search",
        "description": "Scrape public GETTR profiles, user timelines, posts, search results, media URLs, author data, and engagement metrics with a fast Python API-first Apify Actor.",
        "version": "0.0",
        "x-build-id": "UKUO9iazeJhmBEapw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thescrapelab~apify-gettr-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thescrapelab-apify-gettr-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/thescrapelab~apify-gettr-scraper/runs": {
            "post": {
                "operationId": "runs-sync-thescrapelab-apify-gettr-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/thescrapelab~apify-gettr-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-thescrapelab-apify-gettr-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "GETTR URLs",
                        "type": "array",
                        "description": "Paste GETTR profile, post, or search URLs. You can also use the username and search term fields below instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "GETTR usernames to scrape. The @ prefix is optional. The Actor collects the profile and public timeline posts.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords or hashtags to search on GETTR. Use this for discovery and monitoring workflows.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of users/posts to push to the dataset across all targets.",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of concurrent HTTP requests. Keep the default unless you need to tune speed versus rate-limit risk.",
                        "default": 12
                    },
                    "includeRawData": {
                        "title": "Include raw API data",
                        "type": "boolean",
                        "description": "Save original GETTR API fragments in each dataset item for auditability. Leave disabled for cleaner, smaller exports.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Automatic Apify Proxy works for most users; residential proxies can help for larger runs if your account has access.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
