# X(Twitter) Article to Markdown (`fastcrawler/x-twitter-article-to-markdown`) Actor

A high-fidelity extractor that converts X (Twitter) articles into clean, valid Markdown. It delivers a raw UTF-8 string optimized for seamless integration with Obsidian, Notion, and static site generators. Perfect for archival and knowledge management.

- **URL**: https://apify.com/fastcrawler/x-twitter-article-to-markdown.md
- **Developed by:** [fastcrawler](https://apify.com/fastcrawler) (community)
- **Categories:** AI, Social media, Agents
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 mdresults

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## X (Twitter) Article to Markdown Fetcher

A powerful utility designed to bridge the gap between social media long-form content and your personal knowledge management system. This actor extracts the full content of X (Twitter) articles and transforms them into beautifully formatted Markdown.

### ✨ Features

- **Clean Extraction**: Strips away social media clutter (ads, sidebars, tracking scripts) to focus purely on the content.
- **Valid Markdown**: Generates standard-compliant Markdown compatible with **Obsidian**, **Notion**, **Logseq**, and **Bear**.
- **Static Site Ready**: Outputs raw UTF-8 strings, making it easy to pipe content directly into **Hugo**, **Jekyll**, or **Gatsby** workflows.
- **Media Preservation**: Intelligently handles images and links embedded within the article.

### 🛠 Use Cases

1. **Digital Archiving**: Save your favorite long-form X content permanently in your local markdown vault.
2. **CMS Integration**: Automatically sync your X Articles to your personal blog or documentation site.
3. **Research & Citation**: Easily quote and reference high-quality threads and articles in academic or professional projects.

### 📥 Input Requirements

| Field | Type | Description |
| :--- | :--- | :--- |
| **tweetIds** | Array | List of tweet IDs to analyze (optional if URLs are provided). |

### 📤 Output

The Actor returns a structured JSON for each tweet, including:

```json
[
  {
    "tweet_id": "2043777708430414218",
    "md": ""
  },
  {
    "tweet_id": "2034246147318202855",
    "md": "## OpenClaw 高级篇：把 Agent 变成你的数字员工（小白慎入）\n\n中级篇解决了三个问题：记不住、找不到、断不了\n\n但你可能发现——agent 变聪明了，你还是得一步步告诉它做什么\n\n就像你培训了一个实习生，记忆力好、搜索快、不掉线。但每件事还是要你下指令，你说一步他走一步\n\n高级篇要解决的就是这个问题：让实习生变成正式员工\n\n正式员工需要什么？\n\n岗前培训（Skill）——让它懂你的业务\n工作 SOP（Hook）——让它自动按规矩办事\n系统权限（MCP）——让它能用公司的工具\n独立负责项目（自主任务）——让它自己干活\n\n由于确实比较复杂，所以我们每个方向讲透核心概念 + 一个杀手案例\n\n### 一、Skill——给员工做岗前培训\n\n你每天告诉 agent 日报格式：先写完成的工作、再写重要决策、最后写明天计划\n\n说了五十遍，换个 session 又忘了\n\n不是 agent 不聪明，是你教的东西全存在对话里——session 断了就没了\n\n本质问题：对话里教的东西是临时的\n\nSkill 是什么？\n\n一句话：Skill = 给 agent 的培训手册，装进去就永久生效\n\n它的本质是一个 [SKILL.md](http://skill.md/) 文件，放在 skills/ 目录下。agent 启动时扫描这个目录，识别触发词，匹配到就把 [SKILL.md](http://skill.md/) 的内容注入到 context 里\n\n和 [AGENTS.md](http://agents.md/) 有什么区别？\n\n[AGENTS.md](http://agents.md/) 是通用工作规范——怎么写文件、怎么搜索、犯了错怎么记录。每次 session 都加载，不管你干什么\n\nSkill 是特定业务流程和知识——你的日报格式长什么样、你的代码规范是什么、你的搜索工具怎么用。只在需要的时候加载，按触发词匹配\n\n[AGENTS.md](http://agents.md/) 管的是工作态度，Skill 管的是业务知识\n\n或者说——Skill 管「知道什么」\n\n杀手案例：一个日报 Skill\n\n没有 Skill 的时候，每次写日报你要说一大段：\n\n帮我写今天的日报，格式是这样的：先列今天完成的主要任务，然后是重要决策，\n再是遇到的问题和解决方案，最后是明天的计划\n去读今天的 memory 文件提取内容\n\n五十个字的指令，每天说一遍\n\n有了 Skill 之后，创建一个文件 ~/.openclaw/skills/daily-report/SKILL.md\n\n---\nname: daily-report\ndescription: >\n  Generate daily work reports by reading memory files and summarizing activities.\n  Triggers: \"daily report\", \"日报\", \"今天做了什么\", \"工作总结\".\n---\n\n## Daily Report Skill\n\nWhen triggered:\n1. Read today's memory file (memory/YYYY-MM-DD.md)\n2. Extract key activities, decisions, and issues\n3. Format as:\n   - 完成的工作\n   - 重要决策\n   - 遇到的问题\n   - 明天计划\n\n从此你只需要说三个字：写日报\n\nagent 匹配到触发词，自动加载 [SKILL.md](http://skill.md/)，知道该读什么文件、用什么格式、怎么输出\n\n五十个字变三个字。而且不管换多少次 session，格式永远一致\n\nSkill 不是单独存在的，它和 Hook、MCP 组成了一套完整的 agent 增强体系\n\n先做个预览，后面每个方向会详细展开：\n\n![image](https://pbs.twimg.com/media/HDqZ_0CbEAUTkkQ.png)\n\nSkill 管知道什么，Hook 管自动做什么，MCP 管能做什么\n\n记住这句话，后面反复会用\n\n完整的 Skill 开发教程——从目录结构到触发机制到踩坑记录——在高级的完整篇中\n\n### 二、Hook——给员工定 SOP\n\n每次开新 session 你都要说一遍：先看一下今天的计划和日记\n\n说了一百遍，终于想明白一件事——\n\n这件事不应该由我来记\n\n我是老板，不是提词器。我不应该每次开会前提醒秘书翻开笔记本——这件事应该是自动的\n\nHook 是什么？Hook = agent 的反射弧\n\n什么是反射弧？膝跳反射。锤子敲膝盖，腿自动弹，信号走脊髓，不经过大脑\n\nHook 就是这个东西——特定事件发生时，代码直接跑，不经过 agent 思考，不需要 LLM 决策\n\n这和 Skill 是两个层面：\n\nSkill 是给 agent 一本操作手册——它可能看可能不看，看了也可能理解偏了\nHook 是装了一个传感器加执行器——事件一来，代码直接跑，100% 确定执行\n\n关键区别：Hook 跑的是 TypeScript 代码，不是 LLM 决策\n\n一个是建议，一个是铁律。你给员工说「每天早上先看邮件」，他可能忘。你给他定个 SOP 配上闹钟提醒，他想忘都忘不了\n\nHook 的结构也很简单：\n\nmy-hook/\n├── HOOK.md          ## 声明监听什么事件\n└── handler.ts       ## 事件触发时跑什么代码\n\n[HOOK.md](http://hook.md/) 告诉系统「我叫什么名字、监听哪些事件」\nhandler.ts 告诉系统「事件来了具体干什么」\n\n依旧案例：一个 Hook 让 agent 自动读今天的计划\n\n每次开新 session，你想让 agent 自动读取今天的日记文件——不用你说\n\n创建 hooks/session-loader/HOOK.md：\n\n---\nname: session-loader\ndescription: \"新 session 自动加载今天的工作日志\"\nmetadata:\n  openclaw:\n    events: [\"command:new\"]\n    requires:\n      bins: [\"node\"]\n---\n\n创建 hooks/session-loader/handler.ts：\n\nimport { readFileSync, existsSync } from \"fs\";\nimport { join } from \"path\";\n\nconst handler = async (event) => {\n  if (event.type !== \"command\" || event.action !== \"new\") {\n    return;\n  }\n\n  const memoryDir = join(process.cwd(), \"memory\");\n  const today = new Date().toISOString().split(\"T\")[0];\n  const diaryPath = join(memoryDir, `${today}.md`);\n\n  if (existsSync(diaryPath)) {\n    const content = readFileSync(diaryPath, \"utf-8\");\n    event.messages.push(`今天的工作日志已加载：\n${content}`);\n  } else {\n    event.messages.push(\"今天还没有工作日志，开始新的一天\");\n  }\n};\n\nexport default handler;\n\n效果：你打开一个新 session，agent 已经知道今天要做什么了\n\n不用你说「先看一下今天的计划」——这句话从此从你的工作流里消失了\n\n你不需要会 TypeScript。把需求描述清楚——「在什么时机做什么事」——让你的 agent 帮你写 handler.ts 就行\n\n核心能力不是写代码，是定义清楚 trigger + action。这是 PM 天天在做的事\n\n进阶场景\n\nHook 能做的远不止加载日记：\n\n- 监听 compact 事件：context 被压缩前自动保存任务状态，压缩后自动恢复——中级篇的计划文件模式，用 Hook 变成全自动\n- 监听 write 操作：拦截危险的文件覆盖——345KB 事故不会再发生\n- 配合 Heartbeat：每次心跳自动检查有没有未完成的任务\n\n从「你提醒 agent」变成「agent 自己知道」——这就是 反射弧 的力量\n\n几种实用 Hook 配置模板 + 完整踩坑记录在在高级完整篇中\n\n### 三、MCP——给员工开系统权限\n\n你想让 agent 帮你查数据库里的数据，它说：我没有这个能力\n\n你想让它帮你操作文件系统里的特定目录。它说：我做不到\n\nagent 默认只会两件事：思考和对话。其他什么都不能做\n\n你得给它接外设\n\nMCP 是什么？MCP = Model Context Protocol\n\n一句话：AI 世界的 USB 接口\n\n不管什么外部服务——数据库、搜索引擎、文件系统、浏览器——只要支持 MCP 协议，就能接到你的 agent 上\n\n你不需要为每个服务写专用的对接代码。就像 USB 统一了外设接口——不管你是打印机还是摄像头，同一种插头\n\n学会了 USB，以后不管插什么设备都不用重新学。MCP 也一样\n\n架构很简单：\n\nAgent → mcporter（桥梁）→ MCP Server → 外部服务\n\nmcporter 是中间件，负责 agent 和 MCP Server 之间的通信。OpenClaw 内置了 mcporter 的 skill，agent 知道怎么调用它\n\n配置文件在 config/mcporter.json——每个项目可以接不同的外部服务\n\n杀手案例：一条配置让 agent 读写文件系统\n\n最简单的 MCP Server 是文件系统——不需要任何 API key，纯本地跑\n\n在 config/mcporter.json 里写一段配置：\n\n{\n  \"mcpServers\": {\n    \"filesystem\": {\n      \"command\": \"npx\",\n      \"args\": [\"-y\", \"@modelcontextprotocol/server-filesystem\", \"/tmp/mcp-test\"]\n    }\n  }\n}\n\n三行就够了。意思是：启动一个文件系统 MCP Server，只允许它访问 /tmp/mcp-test 目录\n\n最后那个路径是安全边界——限制 Server 只能读写这个目录下的文件。和给 app 设权限一个道理\n\n配好之后验证一下：\n\nmcporter list\n## 看到 filesystem Server 和它暴露的工具就说明成功了\n\nmcporter call filesystem read_file path=/tmp/mcp-test/test.txt\n## 读取测试文件\n\n在 agent 对话中你可以直接说「帮我用 MCP 读取 /tmp/mcp-test 下的文件」——agent 会自动走 mcporter 调用\n\n没接 MCP 的 agent 只会聊天\n接了 MCP 的 agent 能用工具干活\n\n这就是「开系统权限」的意思\n\n生态\n\nMCP 不只是能接文件系统。官方和社区已经有大量现成的 Server：\n\n- 文件系统（本地文件读写）\n- PostgreSQL / SQLite（数据库查询）\n- Brave Search（搜索引擎）\n- Puppeteer（浏览器自动化）\n- Memory（持久化记忆）\n\n一个 USB 接口，无限外设。配一个新 Server 只需要在 mcporter.json 里加几行配置——流程和上面的文件系统一模一样\n\n不要为了用 MCP 而用 MCP。简单的文件读写 agent 自带工具就行，MCP 适合的是需要接外部 API、需要标准化多个外部服务调用方式的场景\n\nMCP 安装配置完整教程 + 常见报错解决方案在深度篇\n\n### 四、自主任务——给员工独立负责项目\n\n你说：帮我做一个社区趋势调研，Agent 说：好的，第一步是什么？\n\n它在等你指挥\n\n你说第一步搜索 GitHub，它搜了。然后等你说第二步\n\n你说第二步搜索 Reddit，它搜了。然后又等你\n\n你想要的不是这样。你想给它一个目标，它自己拆解步骤、自己执行、自己判断完没完成\n\n你说一步它走一步——这是实习生\n你给目标它自己干——这才是正式员工\n\n核心概念：从指令驱动到目标驱动\n\n这是中级篇到高级篇最大的认知升级\n\n指令驱动：你给步骤，agent 执行。中级篇教的计划文件模式就是这个——你手动创建计划、列出步骤、agent 按步骤走\n\n目标驱动：你给目标，agent 自己拆解为子任务、自己规划执行顺序、自己判断有没有完成\n\n实现这个需要三个基础设施，中级篇其实都教过了：\n\n- 计划文件——agent 自己创建和更新，而不是你替它写\n- Heartbeat——每 30 分钟推醒 agent，让它检查有没有事要做\n- [AGENTS.md](http://agents.md/) 规则——告诉 agent 遇到目标型任务怎么拆解、怎么执行、怎么评估\n\n杀手案例：给一个目标，agent 自己拆了 6 个步骤执行\n\n实际案例：我给 agent 一个目标——完成高级篇 6 个方向的素材采集\n\n我只说了一句话：按照素材采集 prompt 里的 6 个方向，逐个完成调研和实战\n\nagent 做了什么：\n\n1. 自己读取了目标文档，理解 6 个方向的具体要求\n1. 自己创建了计划文件 temp/advanced-material-plan.md\n1. 把 6 个方向拆成 6 个阶段，每个阶段有明确的产出物\n1. 从第一个方向开始执行——搜索文档、实战测试、记录踩坑\n1. 每完成一个阶段，自动更新计划文件的进度\n1. Heartbeat 定期检查，确保 agent 没有忘了自己在做什么\n\n中间 context 被压缩了两次，跨了三个 session\n\n但每次新 session 开始，agent 读取计划文件，接着上次的进度继续。没丢任何进度\n\n最终产出了 5 份素材文件，加起来超过 160KB\n\n中级篇教的计划文件 + Heartbeat = 基础设施，高级篇的自主任务 = 在基础设施上搭建自主性\n\n中级篇：你创建计划文件，agent 按计划执行，高级篇：agent 自己创建计划文件，自己按计划执行\n\n![image](https://pbs.twimg.com/media/HDqahkabgAANecR.png)\n\n养出来的能力，现在用起来了\n\n不是所有任务都适合目标驱动——简单的事情直接给指令更快。但当任务复杂到你自己都不确定该分几步的时候，让 agent 试试\n\n完整的自主任务配置 + 踩坑记录在高级完整篇中\n\n四件装备，一句话回顾：\n\nSkill 让它懂业务\nHook 让它按规矩\nMCP 让它用工具\n自主任务让它独立干活\n\n从中级到高级，不是学了四个新概念——而是把中级篇养出来的能力用起来了\n\n中级篇的搜索策略 → 高级篇的工具选择（MCP 加入决策树）\n中级篇的计划文件 → 高级篇的自主任务（agent 自己创建和更新计划）\n中级篇的 Heartbeat → 高级篇的自动化（Hook 让所有手动操作变成自动的）\n\n基础篇教你装上能用，中级篇教你养好好用，高级篇教你落地真正干活\n\n每个方向的完整教程——手把手配置、完整代码、踩坑记录——都在社群飞书文档里\n\n但说实话，教程只是社群的一部分\n\n说说现在群里在发生什么\n\n### 超进化个体——现在群里在发生什么\n\n从3.16号晚上，正式创办社群，到现在社群已经大几十人了\n\n我当时最怕的事没有发生——群没有变成「教程分发群」\n\n高手们在里面互相交叉验证配置方案，各种出海信息差\n\n有高手群友刚进群就搞了一个markdown转其他格式的skill-agent reader skill\n\n![image](https://pbs.twimg.com/media/HDrTrS4aEAAGlBJ.jpg)\n\n![image](https://pbs.twimg.com/media/HDrUA-naMAA_6U7.jpg)\n\n小白的进步也是我没想到的\n\n高级篇你也看到了，Hook要写TypeScript，MCP要配JSON——很多人卡在这一步\n\n所以我在社群里迅速补了一套AI编程教程，从零开始教你怎么用AI帮你写需求\n\n海外支付怎么开通、怎么一行代码不写就能变成高手——这些很多人私信问的问题，我在社群里写了完整的手把手教程，扫完就能照着做\n\n![image](https://pbs.twimg.com/media/HDrUfT6bEAMEewo.jpg)\n\n不需要你会编程，你只需要会描述需求\n\n有个群友之前连终端都没打开过，现在已经用AI写出了自己的第一个skill，学会用cursor调试自己的openclaw了\n\n![image](https://pbs.twimg.com/media/HDrU1DKbEAMELjI.png)\n\n群友的反馈我就不多说了，放了截图，大家自己看\n\n![image](https://pbs.twimg.com/media/HDrVNzBaIAAahBv.jpg)\n\n![image](https://pbs.twimg.com/media/HDrVczVbEAE1e3R.jpg)\n\n你能拿到什么：\n\n【内容】\n→ 基础篇+中级篇+高级篇完整教程，飞书文档持续更新\n→ AI编程入门教程——不会代码也能自己维护自己的openclaw\n→ 海外支付开通指南 + 低成本claude使用方案\n→ 龙虾总结文档，复制给你的agent直接获得整套框架\n→ 每月深度分享——AI、生意、自媒体、商业机会\n\n【互动】\n\n→ 群内集中答疑，高手和小白都在\n→ 群友共建，你的实战案例收录进教程，署名展示\n→ 好内容我quote助推，1w粉曝光直接给你\n\n【资源】\n→ 500元/小时1v1咨询（外部1500），AI、自媒体、商业都能聊\n→ 高级篇+深度篇优先更新\n\n现在249元，已经涨过一次价了\n\n200人封顶不再开放，我不想人多了服务不好\n\n最后请大家相信一个产品经理的职业素养，没有一个产品经理会不认真对待自己产品的付费用户，感谢大家的支持！"
  }
]

````

# Actor input Schema

## `tweetIds` (type: `array`):

The  id of the tweet to get md. Up to 10 items

## Actor input object example

```json
{
  "tweetIds": [
    "2043777708430414218"
  ]
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "tweetIds": [
        "2043777708430414218"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fastcrawler/x-twitter-article-to-markdown").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 = { "tweetIds": ["2043777708430414218"] }

# Run the Actor and wait for it to finish
run = client.actor("fastcrawler/x-twitter-article-to-markdown").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 '{
  "tweetIds": [
    "2043777708430414218"
  ]
}' |
apify call fastcrawler/x-twitter-article-to-markdown --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fastcrawler/x-twitter-article-to-markdown",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "X(Twitter) Article to Markdown",
        "description": "A high-fidelity extractor that converts X (Twitter) articles into clean, valid Markdown. It delivers a raw UTF-8 string optimized for seamless integration with Obsidian, Notion, and static site generators. Perfect for archival and knowledge management.",
        "version": "0.0",
        "x-build-id": "KCE2Tnn8t93NfrqqZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fastcrawler~x-twitter-article-to-markdown/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fastcrawler-x-twitter-article-to-markdown",
                "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/fastcrawler~x-twitter-article-to-markdown/runs": {
            "post": {
                "operationId": "runs-sync-fastcrawler-x-twitter-article-to-markdown",
                "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/fastcrawler~x-twitter-article-to-markdown/run-sync": {
            "post": {
                "operationId": "run-sync-fastcrawler-x-twitter-article-to-markdown",
                "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",
                "required": [
                    "tweetIds"
                ],
                "properties": {
                    "tweetIds": {
                        "title": "tweetIds (Up to 10 items)",
                        "type": "array",
                        "description": "The  id of the tweet to get md. Up to 10 items",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
