@apitwitter/sdk 1.0.0

package/README.md

@@ -0,0 +1,148 @@
+# ApiTwitter JavaScript/TypeScript SDK
+
+Official SDK for the [ApiTwitter](https://apitwitter.com) REST API — access Twitter/X data without the official developer portal.
+
+## Installation
+
+```bash
+npm install apitwitter
+```
+
+## Quick Start
+
+```typescript
+import { ApiTwitter } from "apitwitter";
+
+const client = new ApiTwitter("your-api-key");
+
+// Get user profile (uses server pool — no cookies needed)
+const user = await client.getUser("elonmusk");
+console.log(user.name, user.followers);
+
+// Search tweets
+const results = await client.search("javascript", "Top", 10);
+results.tweets.forEach((tweet) => console.log(tweet.text));
+
+// Get user tweets
+const tweets = await client.getUserTweets("elonmusk");
+```
+
+## Read Operations (Server Pool)
+
+No cookies or proxy needed:
+
+```typescript
+const client = new ApiTwitter("your-api-key");
+
+// Users
+const user = await client.getUser("username");
+const userById = await client.getUserById("12345");
+const users = await client.getUsersBatch(["id1", "id2"]);
+const followers = await client.getFollowers("username", 100);
+const following = await client.getFollowing("username", 100);
+
+// Tweets
+const tweets = await client.getUserTweets("username");
+const tweetsById = await client.getTweets(["id1", "id2"]);
+
+// Search (product: "Top" | "Latest" | "People" | "Photos" | "Videos")
+const results = await client.search("query", "Top", 20);
+```
+
+## Write Operations (Own Credentials)
+
+Requires your own Twitter cookies and proxy:
+
+```typescript
+const creds = {
+  cookie: "ct0=...;auth_token=...",
+  proxy: "http://user:pass@host:port",
+};
+
+// Tweet
+await client.createTweet("Hello from ApiTwitter!", creds);
+
+// Like / unlike
+await client.like("tweet_id", creds);
+await client.unlike("tweet_id", creds);
+
+// Retweet
+await client.retweet("tweet_id", creds);
+
+// Follow / unfollow
+await client.follow("user_id", creds);
+await client.unfollow("user_id", creds);
+
+// DM
+await client.sendDm("user_id", "Hello!", creds);
+
+// Bookmarks
+await client.addBookmark("tweet_id", creds);
+const bookmarks = await client.getBookmarks(creds);
+
+// Timeline
+const foryou = await client.getTimelineForYou(creds, 20);
+const latest = await client.getTimelineLatest(creds, 20);
+```
+
+## Pagination
+
+```typescript
+let result = await client.getFollowers("username", 100);
+let allFollowers = [...result.followers];
+
+while (result.next_cursor) {
+  result = await client.getFollowers("username", 100, result.next_cursor);
+  allFollowers.push(...result.followers);
+}
+```
+
+## Error Handling
+
+```typescript
+import {
+  ApiTwitter,
+  AuthenticationError,
+  InsufficientCreditsError,
+  RateLimitError,
+  NotFoundError,
+} from "apitwitter";
+
+const client = new ApiTwitter("your-api-key");
+
+try {
+  const user = await client.getUser("username");
+} catch (err) {
+  if (err instanceof AuthenticationError) {
+    console.log("Invalid API key");
+  } else if (err instanceof InsufficientCreditsError) {
+    console.log("Top up your balance");
+  } else if (err instanceof RateLimitError) {
+    console.log(`Rate limited, retry after ${err.retryAfter}s`);
+  } else if (err instanceof NotFoundError) {
+    console.log("User not found");
+  }
+}
+```
+
+## Configuration
+
+```typescript
+// Simple
+const client = new ApiTwitter("your-api-key");
+
+// With options
+const client = new ApiTwitter({
+  apiKey: "your-api-key",
+  baseUrl: "https://api.apitwitter.com", // default
+  timeout: 30, // seconds
+});
+```
+
+## Links
+
+- [Documentation](https://docs.apitwitter.com)
+- [API Reference](https://docs.apitwitter.com/api-reference)
+- [Website](https://apitwitter.com)
+- [Get API Key](https://apitwitter.com/dashboard)
+- [Telegram Support](https://t.me/ApiTwitter)

package/dist/errors.d.ts

@@ -0,0 +1,21 @@
+export declare class ApiTwitterError extends Error {
+    status: number;
+    response: Record<string, unknown>;
+    constructor(message: string, status?: number, response?: Record<string, unknown>);
+}
+export declare class AuthenticationError extends ApiTwitterError {
+    constructor(message: string, response?: Record<string, unknown>);
+}
+export declare class InsufficientCreditsError extends ApiTwitterError {
+    constructor(message: string, response?: Record<string, unknown>);
+}
+export declare class RateLimitError extends ApiTwitterError {
+    retryAfter: number;
+    constructor(message: string, retryAfter?: number, response?: Record<string, unknown>);
+}
+export declare class NotFoundError extends ApiTwitterError {
+    constructor(message: string, response?: Record<string, unknown>);
+}
+export declare class ValidationError extends ApiTwitterError {
+    constructor(message: string, response?: Record<string, unknown>);
+}

package/dist/errors.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = exports.NotFoundError = exports.RateLimitError = exports.InsufficientCreditsError = exports.AuthenticationError = exports.ApiTwitterError = void 0;
+class ApiTwitterError extends Error {
+    constructor(message, status = 0, response = {}) {
+        super(message);
+        this.name = "ApiTwitterError";
+        this.status = status;
+        this.response = response;
+    }
+}
+exports.ApiTwitterError = ApiTwitterError;
+class AuthenticationError extends ApiTwitterError {
+    constructor(message, response) {
+        super(message, 401, response);
+        this.name = "AuthenticationError";
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class InsufficientCreditsError extends ApiTwitterError {
+    constructor(message, response) {
+        super(message, 402, response);
+        this.name = "InsufficientCreditsError";
+    }
+}
+exports.InsufficientCreditsError = InsufficientCreditsError;
+class RateLimitError extends ApiTwitterError {
+    constructor(message, retryAfter = 0, response) {
+        super(message, 429, response);
+        this.name = "RateLimitError";
+        this.retryAfter = retryAfter;
+    }
+}
+exports.RateLimitError = RateLimitError;
+class NotFoundError extends ApiTwitterError {
+    constructor(message, response) {
+        super(message, 404, response);
+        this.name = "NotFoundError";
+    }
+}
+exports.NotFoundError = NotFoundError;
+class ValidationError extends ApiTwitterError {
+    constructor(message, response) {
+        super(message, 400, response);
+        this.name = "ValidationError";
+    }
+}
+exports.ValidationError = ValidationError;

package/dist/index.d.ts

@@ -0,0 +1,90 @@
+import { ApiTwitterError, AuthenticationError, InsufficientCreditsError, RateLimitError, NotFoundError, ValidationError } from "./errors";
+export { ApiTwitterError, AuthenticationError, InsufficientCreditsError, RateLimitError, NotFoundError, ValidationError, };
+interface ClientOptions {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+interface Credentials {
+    cookie: string;
+    proxy: string;
+    userAgent?: string;
+}
+export declare class ApiTwitter {
+    private apiKey;
+    private baseUrl;
+    private timeout;
+    constructor(options: ClientOptions | string);
+    private request;
+    private get;
+    private post;
+    private del;
+    private patch;
+    private creds;
+    verifySession(creds: Credentials): Promise<unknown>;
+    getUser(username: string): Promise<unknown>;
+    getUserById(userId: string): Promise<unknown>;
+    getUsersBatch(userIds: string[]): Promise<unknown>;
+    getFollowers(username: string, count?: number, cursor?: string): Promise<unknown>;
+    getFollowing(username: string, count?: number, cursor?: string): Promise<unknown>;
+    getFollowersYouKnow(username: string, count?: number, cursor?: string): Promise<unknown>;
+    getUserPost(username: string, creds: Credentials): Promise<unknown>;
+    getUserLikes(username: string, creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    getUserMedia(username: string, creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    getUserReplies(username: string, creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    getBlocked(creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    getMuted(creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    removeFollower(userId: string, creds: Credentials): Promise<unknown>;
+    getUserTweets(username: string, cursor?: string): Promise<unknown>;
+    getTweets(tweetIds: string[]): Promise<unknown>;
+    search(query: string, product?: string, count?: number, cursor?: string): Promise<unknown>;
+    createTweet(text: string, creds: Credentials, replyTo?: string): Promise<unknown>;
+    deleteTweet(tweetId: string, creds: Credentials): Promise<unknown>;
+    retweet(tweetId: string, creds: Credentials): Promise<unknown>;
+    unretweet(tweetId: string, creds: Credentials): Promise<unknown>;
+    pinTweet(tweetId: string, creds: Credentials): Promise<unknown>;
+    unpinTweet(tweetId: string, creds: Credentials): Promise<unknown>;
+    like(tweetId: string, creds: Credentials): Promise<unknown>;
+    unlike(tweetId: string, creds: Credentials): Promise<unknown>;
+    follow(userId: string, creds: Credentials): Promise<unknown>;
+    unfollow(userId: string, creds: Credentials): Promise<unknown>;
+    sendDm(userId: string, text: string, creds: Credentials): Promise<unknown>;
+    dmBlock(userId: string, creds: Credentials): Promise<unknown>;
+    dmUnblock(userId: string, creds: Credentials): Promise<unknown>;
+    addBookmark(tweetId: string, creds: Credentials): Promise<unknown>;
+    removeBookmark(tweetId: string, creds: Credentials): Promise<unknown>;
+    getBookmarks(creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    getTimelineForYou(creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    getTimelineLatest(creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    searchPost(query: string, creds: Credentials, product?: string, count?: number, cursor?: string): Promise<unknown>;
+    createList(name: string, creds: Credentials, options?: {
+        description?: string;
+        isPrivate?: boolean;
+    }): Promise<unknown>;
+    deleteList(listId: string, creds: Credentials): Promise<unknown>;
+    updateList(listId: string, creds: Credentials, updates: {
+        name?: string;
+        description?: string;
+        isPrivate?: boolean;
+    }): Promise<unknown>;
+    getListInfo(listId: string, creds: Credentials): Promise<unknown>;
+    getListTweets(listId: string, creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    getListMembers(listId: string, creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    addListMember(listId: string, userId: string, creds: Credentials): Promise<unknown>;
+    removeListMember(listId: string, userId: string, creds: Credentials): Promise<unknown>;
+    getOwnedLists(userId: string, creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    getListMemberships(userId: string, creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    getListSubscribers(listId: string, creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    subscribeToList(listId: string, creds: Credentials): Promise<unknown>;
+    unsubscribeFromList(listId: string, creds: Credentials): Promise<unknown>;
+    exploreCommunities(creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    getCommunity(communityId: string, creds: Credentials): Promise<unknown>;
+    joinCommunity(communityId: string, creds: Credentials): Promise<unknown>;
+    leaveCommunity(communityId: string, creds: Credentials): Promise<unknown>;
+    getCommunityTweets(communityId: string, creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    getCommunityMedia(communityId: string, creds: Credentials, count?: number, cursor?: string): Promise<unknown>;
+    getTopic(topicId: string, creds: Credentials): Promise<unknown>;
+    followTopic(topicId: string, creds: Credentials): Promise<unknown>;
+    unfollowTopic(topicId: string, creds: Credentials): Promise<unknown>;
+}
+export default ApiTwitter;

package/dist/index.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiTwitter = exports.ValidationError = exports.NotFoundError = exports.RateLimitError = exports.InsufficientCreditsError = exports.AuthenticationError = exports.ApiTwitterError = void 0;
+const errors_1 = require("./errors");
+Object.defineProperty(exports, "ApiTwitterError", { enumerable: true, get: function () { return errors_1.ApiTwitterError; } });
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return errors_1.AuthenticationError; } });
+Object.defineProperty(exports, "InsufficientCreditsError", { enumerable: true, get: function () { return errors_1.InsufficientCreditsError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_1.RateLimitError; } });
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return errors_1.NotFoundError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_1.ValidationError; } });
+class ApiTwitter {
+    constructor(options) {
+        if (typeof options === "string") {
+            this.apiKey = options;
+            this.baseUrl = "https://api.apitwitter.com";
+            this.timeout = 30000;
+        }
+        else {
+            this.apiKey = options.apiKey;
+            this.baseUrl = (options.baseUrl || "https://api.apitwitter.com").replace(/\/$/, "");
+            this.timeout = (options.timeout || 30) * 1000;
+        }
+    }
+    // -- internal helpers --
+    async request(method, path, body, params) {
+        const url = new URL(path, this.baseUrl);
+        if (params) {
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined && v !== null)
+                    url.searchParams.set(k, String(v));
+            }
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const resp = await fetch(url.toString(), {
+                method,
+                headers: {
+                    "X-API-Key": this.apiKey,
+                    "Content-Type": "application/json",
+                },
+                body: body ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+            let data;
+            try {
+                data = (await resp.json());
+            }
+            catch {
+                data = { msg: await resp.text() };
+            }
+            if (resp.ok)
+                return data.data ?? data;
+            const msg = String(data.msg || data.message || JSON.stringify(data));
+            const status = resp.status;
+            if (status === 401)
+                throw new errors_1.AuthenticationError(msg, data);
+            if (status === 402)
+                throw new errors_1.InsufficientCreditsError(msg, data);
+            if (status === 404)
+                throw new errors_1.NotFoundError(msg, data);
+            if (status === 429)
+                throw new errors_1.RateLimitError(msg, Number(data.retry_after) || 0, data);
+            if (status === 400)
+                throw new errors_1.ValidationError(msg, data);
+            throw new errors_1.ApiTwitterError(msg, status, data);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    get(path, params) {
+        return this.request("GET", path, undefined, params);
+    }
+    post(path, body) {
+        return this.request("POST", path, body);
+    }
+    del(path, body) {
+        return this.request("DELETE", path, body);
+    }
+    patch(path, body) {
+        return this.request("PATCH", path, body);
+    }
+    creds(c) {
+        const o = { cookie: c.cookie, proxy: c.proxy };
+        if (c.userAgent)
+            o.user_agent = c.userAgent;
+        return o;
+    }
+    // ── Session ────────────────────────────────────────────
+    verifySession(creds) {
+        return this.post("/twitter/session/verify", this.creds(creds));
+    }
+    // ── Users (GET — pool) ─────────────────────────────────
+    getUser(username) {
+        return this.get(`/twitter/user/${username}`);
+    }
+    getUserById(userId) {
+        return this.get(`/twitter/user/id/${userId}`);
+    }
+    getUsersBatch(userIds) {
+        return this.get("/twitter/users/batch", { userIds: userIds.join(",") });
+    }
+    getFollowers(username, count = 200, cursor) {
+        return this.get(`/twitter/user/${username}/followers`, { count, cursor });
+    }
+    getFollowing(username, count = 200, cursor) {
+        return this.get(`/twitter/user/${username}/following`, { count, cursor });
+    }
+    getFollowersYouKnow(username, count = 20, cursor) {
+        return this.get(`/twitter/user/${username}/followers-you-know`, { count, cursor });
+    }
+    // ── Users (POST — own credentials) ─────────────────────
+    getUserPost(username, creds) {
+        return this.post(`/twitter/user/${username}`, this.creds(creds));
+    }
+    getUserLikes(username, creds, count = 20, cursor) {
+        return this.post(`/twitter/user/${username}/likes`, { ...this.creds(creds), count, cursor });
+    }
+    getUserMedia(username, creds, count = 20, cursor) {
+        return this.post(`/twitter/user/${username}/media`, { ...this.creds(creds), count, cursor });
+    }
+    getUserReplies(username, creds, count = 20, cursor) {
+        return this.post(`/twitter/user/${username}/replies`, { ...this.creds(creds), count, cursor });
+    }
+    getBlocked(creds, count = 200, cursor) {
+        return this.post("/twitter/blocked", { ...this.creds(creds), count, cursor });
+    }
+    getMuted(creds, count = 200, cursor) {
+        return this.post("/twitter/muted", { ...this.creds(creds), count, cursor });
+    }
+    removeFollower(userId, creds) {
+        return this.post(`/twitter/user/${userId}/remove-follower`, this.creds(creds));
+    }
+    // ── Tweets (GET — pool) ────────────────────────────────
+    getUserTweets(username, cursor) {
+        return this.get(`/twitter/user/${username}/tweets`, { cursor });
+    }
+    getTweets(tweetIds) {
+        return this.get("/twitter/tweets/lookup", { tweet_ids: tweetIds.join(",") });
+    }
+    search(query, product = "Top", count = 20, cursor) {
+        return this.get("/twitter/search", { query, product, count, cursor });
+    }
+    // ── Tweets (POST — own credentials) ────────────────────
+    createTweet(text, creds, replyTo) {
+        const body = { tweet_text: text, ...this.creds(creds) };
+        if (replyTo)
+            body.reply_to_tweet_id = replyTo;
+        return this.post("/twitter/tweets", body);
+    }
+    deleteTweet(tweetId, creds) {
+        return this.del(`/twitter/tweets/${tweetId}`, this.creds(creds));
+    }
+    retweet(tweetId, creds) {
+        return this.post(`/twitter/tweets/${tweetId}/retweet`, this.creds(creds));
+    }
+    unretweet(tweetId, creds) {
+        return this.del(`/twitter/tweets/${tweetId}/retweet`, this.creds(creds));
+    }
+    pinTweet(tweetId, creds) {
+        return this.post(`/twitter/tweets/${tweetId}/pin`, this.creds(creds));
+    }
+    unpinTweet(tweetId, creds) {
+        return this.del(`/twitter/tweets/${tweetId}/pin`, this.creds(creds));
+    }
+    // ── Engagement ─────────────────────────────────────────
+    like(tweetId, creds) {
+        return this.post(`/twitter/tweets/${tweetId}/like`, this.creds(creds));
+    }
+    unlike(tweetId, creds) {
+        return this.post(`/twitter/tweets/${tweetId}/unlike`, this.creds(creds));
+    }
+    follow(userId, creds) {
+        return this.post(`/twitter/user/${userId}/follow`, this.creds(creds));
+    }
+    unfollow(userId, creds) {
+        return this.post(`/twitter/user/${userId}/unfollow`, this.creds(creds));
+    }
+    // ── DM ─────────────────────────────────────────────────
+    sendDm(userId, text, creds) {
+        return this.post(`/twitter/dm/${userId}`, { text, ...this.creds(creds) });
+    }
+    dmBlock(userId, creds) {
+        return this.post(`/twitter/dm/block/${userId}`, this.creds(creds));
+    }
+    dmUnblock(userId, creds) {
+        return this.del(`/twitter/dm/block/${userId}`, this.creds(creds));
+    }
+    // ── Bookmarks ──────────────────────────────────────────
+    addBookmark(tweetId, creds) {
+        return this.post(`/twitter/tweets/${tweetId}/bookmark`, this.creds(creds));
+    }
+    removeBookmark(tweetId, creds) {
+        return this.del(`/twitter/tweets/${tweetId}/bookmark`, this.creds(creds));
+    }
+    getBookmarks(creds, count = 20, cursor) {
+        return this.post("/twitter/bookmarks", { ...this.creds(creds), count, cursor });
+    }
+    // ── Timeline ───────────────────────────────────────────
+    getTimelineForYou(creds, count = 20, cursor) {
+        return this.post("/twitter/timeline/for-you", { ...this.creds(creds), count, cursor });
+    }
+    getTimelineLatest(creds, count = 20, cursor) {
+        return this.post("/twitter/timeline/latest", { ...this.creds(creds), count, cursor });
+    }
+    // ── Search (POST) ──────────────────────────────────────
+    searchPost(query, creds, product = "Top", count = 20, cursor) {
+        return this.post("/twitter/search", { query, ...this.creds(creds), product, count, cursor });
+    }
+    // ── Lists ──────────────────────────────────────────────
+    createList(name, creds, options) {
+        return this.post("/twitter/lists", {
+            name, ...this.creds(creds),
+            description: options?.description,
+            is_private: options?.isPrivate ?? false,
+        });
+    }
+    deleteList(listId, creds) {
+        return this.del(`/twitter/lists/${listId}`, this.creds(creds));
+    }
+    updateList(listId, creds, updates) {
+        return this.patch(`/twitter/lists/${listId}`, {
+            ...this.creds(creds),
+            name: updates.name,
+            description: updates.description,
+            is_private: updates.isPrivate,
+        });
+    }
+    getListInfo(listId, creds) {
+        return this.post(`/twitter/lists/${listId}/info`, this.creds(creds));
+    }
+    getListTweets(listId, creds, count = 20, cursor) {
+        return this.post(`/twitter/lists/${listId}/tweets`, { ...this.creds(creds), count, cursor });
+    }
+    getListMembers(listId, creds, count = 20, cursor) {
+        return this.post(`/twitter/lists/${listId}/members`, { ...this.creds(creds), count, cursor });
+    }
+    addListMember(listId, userId, creds) {
+        return this.post(`/twitter/lists/${listId}/members/${userId}/add`, this.creds(creds));
+    }
+    removeListMember(listId, userId, creds) {
+        return this.post(`/twitter/lists/${listId}/members/${userId}/remove`, this.creds(creds));
+    }
+    getOwnedLists(userId, creds, count = 20, cursor) {
+        return this.post("/twitter/lists/owned", { ...this.creds(creds), user_id: userId, count, cursor });
+    }
+    getListMemberships(userId, creds, count = 20, cursor) {
+        return this.post("/twitter/lists/memberships", { ...this.creds(creds), user_id: userId, count, cursor });
+    }
+    getListSubscribers(listId, creds, count = 20, cursor) {
+        return this.post(`/twitter/lists/${listId}/subscribers`, { ...this.creds(creds), count, cursor });
+    }
+    subscribeToList(listId, creds) {
+        return this.post(`/twitter/lists/${listId}/subscribe`, this.creds(creds));
+    }
+    unsubscribeFromList(listId, creds) {
+        return this.del(`/twitter/lists/${listId}/subscribe`, this.creds(creds));
+    }
+    // ── Communities ────────────────────────────────────────
+    exploreCommunities(creds, count = 20, cursor) {
+        return this.post("/twitter/communities/explore", { ...this.creds(creds), count, cursor });
+    }
+    getCommunity(communityId, creds) {
+        return this.post(`/twitter/communities/${communityId}`, this.creds(creds));
+    }
+    joinCommunity(communityId, creds) {
+        return this.post(`/twitter/communities/${communityId}/join`, this.creds(creds));
+    }
+    leaveCommunity(communityId, creds) {
+        return this.del(`/twitter/communities/${communityId}/join`, this.creds(creds));
+    }
+    getCommunityTweets(communityId, creds, count = 20, cursor) {
+        return this.post(`/twitter/communities/${communityId}/tweets`, { ...this.creds(creds), count, cursor });
+    }
+    getCommunityMedia(communityId, creds, count = 20, cursor) {
+        return this.post(`/twitter/communities/${communityId}/media`, { ...this.creds(creds), count, cursor });
+    }
+    // ── Topics ─────────────────────────────────────────────
+    getTopic(topicId, creds) {
+        return this.post(`/twitter/topics/${topicId}`, this.creds(creds));
+    }
+    followTopic(topicId, creds) {
+        return this.post(`/twitter/topics/${topicId}/follow`, this.creds(creds));
+    }
+    unfollowTopic(topicId, creds) {
+        return this.del(`/twitter/topics/${topicId}/follow`, this.creds(creds));
+    }
+}
+exports.ApiTwitter = ApiTwitter;
+exports.default = ApiTwitter;

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@apitwitter/sdk",
+  "version": "1.0.0",
+  "description": "JavaScript/TypeScript SDK for the ApiTwitter REST API — Twitter/X data access",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["twitter", "api", "sdk", "x", "tweets", "social-media", "typescript"],
+  "author": "ApiTwitter <support@apitwitter.com>",
+  "license": "MIT",
+  "homepage": "https://apitwitter.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/apitwitter/js-sdk"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}