diff --git a/sources/academy/build-and-publish/actor_success_stories.md b/sources/academy/build-and-publish/actor_success_stories.md
deleted file mode 100644
index 49e419aaf..000000000
--- a/sources/academy/build-and-publish/actor_success_stories.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-title: Actor success stories
-description: Learn about developers who successfully make passive income from their Actors.
-sidebar_position: 7
-category: build-and-publish
-slug: /actor-marketing-playbook/store-basics/actor-success-stories
----
-
-_Web scraping freelance financial freedom with microworlds._
-
-Discover how Caleb David, founder of `microworlds`, achieved financial freedom through freelance web scraping. His journey showcases how mastering the craft with tools like Crawlee and creating a Twitter scraper transformed his career. See the full story in this [blog post](https://blog.apify.com/web-scraping-freelance-financial-freedom/) and learn from his success.
-
-https://apify.com/microworlds
-
-_Web scraping for freelance success – insights from Tugkan._
-
-In this success story, our first community dev Tugkan shares how his journey into freelancing via Apify changed his life. Learn about his process, challenges, and how his paid Actors have brought him financial rewards and freedom. Check out his [story](https://apify.com/success-stories/paid-actor-journey-apify-freelancer-tugkan) for inspiration.
-
-https://apify.com/epctex
-
-
-Interested in sharing your story? Reach out to our marketing team at [marketing@apify.com](mailto:marketing@apify.com) for a case study to showcase your journey.
diff --git a/sources/academy/build-and-publish/promoting-your-actor/checklist.md b/sources/academy/build-and-publish/promoting-your-actor/checklist.md
new file mode 100644
index 000000000..d01227282
--- /dev/null
+++ b/sources/academy/build-and-publish/promoting-your-actor/checklist.md
@@ -0,0 +1,271 @@
+---
+title: Marketing checklist
+description: A comprehensive, actionable checklist to promote your Actor. Follow this step-by-step guide to reach more users through social media, content marketing, and community engagement.
+sidebar_position: 0
+category: build-and-publish
+slug: /actor-marketing-playbook/promote-your-actor/checklist
+---
+
+You're a developer, not a marketer. You built something awesome, and now you need people to find it. This checklist breaks down the marketing process into simple, actionable steps.
+
+Complete many tasks using AI prompts that generate content in minutes. Each completed task brings you closer to your goals.
+
+:::tip Tag Apify for broader reach
+
+Tag @apify when you share content on X.com (Twitter) or LinkedIn to potentially reach thousands of additional users through Apify's social channels.
+
+:::
+
+---
+
+import PromptButton from "@site/src/components/PromptButton";
+import { TWITTER_POST_PROMPT } from "@site/src/utils/twitter-post-prompt";
+import { LINKEDIN_POST_PROMPT } from "@site/src/utils/linkedin-post-prompt";
+import { MEDIUM_ARTICLE_PROMPT } from "@site/src/utils/medium-article-prompt";
+import { DEVTO_ARTICLE_PROMPT } from "@site/src/utils/devto-article-prompt";
+import { HASHNODE_ARTICLE_PROMPT } from "@site/src/utils/hashnode-article-prompt";
+import { LINKEDIN_ARTICLE_PROMPT } from "@site/src/utils/linkedin-article-prompt";
+import { DEVTO_TUTORIAL_PROMPT } from "@site/src/utils/devto-tutorial-prompt";
+import { HASHNODE_TUTORIAL_PROMPT } from "@site/src/utils/hashnode-tutorial-prompt";
+import { MEDIUM_TUTORIAL_PROMPT } from "@site/src/utils/medium-tutorial-prompt";
+import { LINKEDIN_TUTORIAL_PROMPT } from "@site/src/utils/linkedin-tutorial-prompt";
+import { REDDIT_COMMENT_PROMPT } from "@site/src/utils/reddit-comment-prompt";
+import { GITHUB_README_PROMPT } from "@site/src/utils/github-readme-prompt";
+import { QUORA_ANSWER_PROMPT } from "@site/src/utils/quora-answer-prompt";
+
+## Social media promotion
+
+### Share on Twitter/X with a demo
+
+Twitter's developer community is active and engaged. A well-crafted tweet with a video demo can reach thousands of potential users.
+
+Create a 30-60 second demo video or gif showing your Actor in action. Include relevant hashtags like #webscraping, #API, #automation, and #buildinpublic.
+
+
+
+### Share on LinkedIn with a demo
+
+LinkedIn reaches professionals, decision-makers, and business users with purchasing power. The platform's algorithm favors native video content, giving it 5x more reach than link posts.
+
+Create a 30-90 second demo video showing your Actor delivering business value. Upload the video directly to LinkedIn (native videos perform better than YouTube links). Focus your post on the business problem solved, not technical features. Use 3-5 relevant hashtags like #BusinessAutomation, #Productivity, #DataIntelligence, #Efficiency, or #MarketResearch.
+
+
+
+### Post in relevant Discord and Slack communities
+
+Developer communities on Discord and Slack are where your target users spend time. These platforms enable deeper conversations and direct feedback.
+
+Join communities related to data for AI, web scraping, automation, data science, or your specific niche. Share your Actor in relevant channels, but always check the community rules first. Consider Apify Discord, web scraping communities, automation groups, and data engineering Slacks.
+
+---
+
+## Video content creation
+
+### Create a tutorial video or walkthrough
+
+Video content ranks well on YouTube and Google. It's perfect for developers who prefer visual learning. Videos get embedded and shared, multiplying your reach.
+
+Record a 5-10 minute screen recording showing your Actor in action. Use Loom, OBS, or your computer's built-in recorder. Distribute your video across multiple channels:
+
+- YouTube
+- LinkedIn
+- Twitter/X
+- Your README and articles
+
+**Video structure:**
+
+1. **Introduction (30-45 seconds)** - Greet viewers, explain the problem you're solving, what they'll learn, and time estimate
+2. **Outcome preview (30-45 seconds)** - Show the result first, preview the final output
+3. **Step-by-step walkthrough (4-7 minutes)** - Navigate to the Actor, set up configuration, show optional features, run the Actor, review results, export the data
+4. **Pro tips (30-60 seconds)** - Share 2-3 quick tips you've learned
+5. **Wrap up (30-45 seconds)** - Recap, call-to-action, engagement prompt
+
+**Recording tips:** Close unnecessary tabs, use a clean browser profile, speak clearly at a moderate pace, pause briefly between steps for easier editing, and use your natural voice.
+
+### Create short-form videos (TikTok, YouTube Shorts, Instagram Reels)
+
+Short-form video is one of the fastest-growing content formats with incredible organic reach. Even accounts with zero followers can get thousands of views. These videos showcase your Actor's value in 15-60 seconds and appear in AI-generated answers and search results.
+
+Focus on the "wow factor": show the problem (manual work taking forever) versus the solution (your Actor doing it in seconds). Use trending sounds when possible, add text overlays explaining what's happening (most people watch without sound), and include a clear call-to-action at the end. Post the same video across all three platforms to maximize reach.
+
+:::tip Best practices for short-form videos
+
+- Hook viewers in the first 3 seconds (show the result or problem immediately)
+- Keep it fast-paced
+- Add captions and text overlays (essential for silent viewing)
+- Record in portrait mode (9:16 aspect ratio)
+- End with a clear next step: "Link in bio" or "Search [Actor Name] on Apify"
+
+:::
+
+---
+
+## Launch and community engagement
+
+### Create a Product Hunt launch
+
+Product Hunt drives significant traffic and visibility. A successful launch brings hundreds of users and valuable feedback.
+
+Create a Product Hunt listing for your Actor. Schedule it for a weekday morning (Tuesday through Thursday works best). Prepare assets: logo, screenshots, and demo video.
+
+Learn more in the [Product Hunt guide](/academy/actor-marketing-playbook/promote-your-actor/product-hunt).
+
+### Submit to Hacker News
+
+Hacker News drives significant developer traffic and has high domain authority. A front-page post brings thousands of visitors and generates discussions that lead to improvements and feature ideas.
+
+Submit your "How I Built This" post, tutorial, or Actor launch with a descriptive title. Post between 8-10 AM EST on weekdays for best results. Engage authentically in comments. The HN community values substance over promotion.
+
+### Promote your Actor on Reddit
+
+Reddit ranks highly for almost all keywords and topics. You can get your product mentioned in LLMs by engaging in popular threads.
+
+1. Search `site:reddit.com [ACTOR NAME]` in Google
+2. Find relevant Reddit threads
+3. Comment authentically and mention your product naturally without being salesy
+
+Craft comments that genuinely address the thread topic, naturally mention your Actor as a solution, and add real value to the conversation. Use casual Reddit tone, not corporate speak.
+
+### Cross-post to relevant subreddits
+
+Original posts in relevant subreddits (r/webdev, r/datascience, r/SideProject, r/programming, r/automation) drive significant traffic when done thoughtfully.
+
+Write a Reddit-native post that explains the problem, your solution, and invites feedback. Use titles like "I built X to solve Y" instead of "Check out my new tool." Follow subreddit self-promotion rules (many require you to be an active community member first). Share both challenges and successes to foster authentic engagement.
+
+### Answer Stack Overflow questions
+
+Stack Overflow answers rank well in search and are frequently referenced by AI systems. Providing helpful answers that mention your Actor creates lasting SEO value.
+
+Search for questions related to your Actor's use case (e.g., "web scraping", "API integration"). Provide genuinely helpful answers that solve the problem, and mention your Actor as one potential solution.
+
+### Contribute to Quora discussions
+
+Quora answers rank well in Google and are often featured in AI-generated answers. People actively seek solutions to problems on this platform.
+
+1. Search `site:quora.com [ACTOR NAME]` or related keywords in Google
+2. Find relevant Quora threads
+3. Write comprehensive, helpful answers and mention your product naturally without being salesy
+
+Write 300-500 word answers that open with a direct response, provide context, offer 2-3 different approaches, mention your Actor as one option, and include personal experience. Use subheadings for readability. Keep tone expert but approachable.
+
+---
+
+## Content marketing
+
+### Write a technical "How I built this" blog post
+
+Developers love reading about other developers' journeys. This positions you as an expert, builds trust, and naturally promotes your Actor while providing educational value. It's great for SEO and getting indexed by AI search engines.
+
+Share your development process, challenges you faced, and how you solved them. Post on dev.to, Medium, Hashnode, or your personal blog.
+
+Learn more in the [Blogs and blog resources guide](/academy/actor-marketing-playbook/promote-your-actor/blogs-and-blog-resources).
+
+### Create a "Best X" article for Medium
+
+Medium has excellent SEO and a massive audience of professionals and developers. Publishing on Medium and submitting to relevant publications like "Better Programming" or "The Startup" can reach thousands of readers. Medium articles frequently appear in Google search results and AI-generated answers.
+
+Write a comprehensive "Best [CATEGORY]" roundup article (1,800-2,500 words) featuring 6-8 solutions with your Actor prominently positioned. Create a Medium account if you don't have one, and publish it. Use all 5 available tags strategically (e.g., "web scraping", "APIs", "automation", "developer tools", "[your specific niche]"). Submit your article to relevant Medium publications to multiply your reach by 10x or more.
+
+Write in first person with a conversational yet professional tone. Include pros and cons for each solution, add a comparison table, and share your genuine perspective.
+
+
+
+### Create a "Best X" article for dev.to
+
+dev.to is the go-to platform for developers seeking tools and tutorials. It has a highly engaged community and strong domain authority, so your articles rank well in search engines. The community actively comments and shares, boosting visibility. dev.to content is frequently referenced by AI tools.
+
+Write a developer-focused "Best [CATEGORY] for Developers" article (1,500-2,000 words) featuring 6-8 solutions. Create a dev.to account if needed and publish your article. Add relevant tags (up to 4 tags, e.g., #webdev, #api, #productivity, #tools). Engage with comments. The dev.to community values authentic interaction.
+
+Write like you're advising a fellow developer: casual and helpful. Be genuinely objective about all tools, include code examples or API snippets where relevant, and use markdown formatting with H2/H3 headers.
+
+
+
+### Create a "Best X" article for Hashnode
+
+Hashnode is a rapidly growing developer blogging platform with excellent SEO and a clean reading experience. It's perfect for technical content with features built for developers (code highlighting, series, custom domains). Articles rank well in search results and are frequently discovered by developers. High-quality content often gets featured on Hashnode's homepage, dramatically increasing visibility.
+
+Write a technical "Best [CATEGORY] for [SPECIFIC USE CASE]: A Developer's Guide" article (1,500-2,000 words). Create a Hashnode account if you don't have one (you can use a custom domain). Publish your article and add it to relevant Hashnode tags and communities.
+
+Include a TL;DR section at the top, use proper heading hierarchy for auto-generated table of contents, and add code examples with proper syntax highlighting. Write with technical authority but remain accessible.
+
+
+
+### Create a "Best X" article for LinkedIn
+
+LinkedIn reaches a professional, business-oriented audience including decision-makers, CTOs, product managers, and team leads who have budget and purchasing authority. LinkedIn articles have strong SEO and are shared within professional networks, multiplying your reach. Content on LinkedIn is frequently indexed by AI systems.
+
+Write a business-focused "Best [CATEGORY] for [BUSINESS OUTCOME]" article (1,200-1,800 words) featuring 5-7 solutions. Publish it as a LinkedIn Article (use the "Write article" feature, not just a post). After publishing, share the article link in a regular LinkedIn post with a compelling intro to drive traffic.
+
+Use a professional, authoritative but accessible tone. Focus on business impact like time savings, cost efficiency, ROI, and productivity gains rather than technical features. Include comparison tables with business-relevant metrics.
+
+
+
+### Create a "How to use [Actor]" tutorial for dev.to
+
+dev.to is the platform for developer tutorials. It has a massive, engaged community that actively searches for and shares how-to content. Tutorials rank exceptionally well in Google and are frequently referenced by AI systems when developers ask "how to" questions.
+
+Write a step-by-step tutorial (1,200-2,000 words) showing developers how to use your Actor to achieve a specific outcome. Create a dev.to account if you don't have one, then publish your article with up to 4 relevant tags (e.g., #tutorial, #webdev, #api, #automation).
+
+Structure: Introduction with hook, prerequisites, what they'll achieve, step-by-step guide (access the Actor, configure inputs, run it, view results, download data), understanding results, pro tips, troubleshooting, and next steps. Write like you're helping a friend get started.
+
+
+
+### Create a "How to use [Actor]" tutorial for Hashnode
+
+Hashnode is perfect for comprehensive technical tutorials with a clean reading experience. It has excellent SEO, strong domain authority, and a growing developer community. The platform is built for technical writing with great code formatting and features like table of contents auto-generation.
+
+Write a comprehensive "Complete Guide: How to [ACHIEVE OUTCOME] Using [YOUR ACTOR NAME]" tutorial (1,800-2,500 words). Sign up for Hashnode if you haven't already. Publish your article and add it to relevant tags.
+
+Include a TL;DR section, detailed step-by-step walkthrough with screenshots, API integration examples with code blocks, advanced usage patterns, troubleshooting guide, and best practices. Write with technical authority, but be thorough and maintain clarity.
+
+
+
+### Create a "How to use [Actor]" tutorial for Medium
+
+Medium reaches a broader, less technical audience. It's perfect for tutorials that appeal to marketers, entrepreneurs, product managers, no-code users, or less technical users. Medium's strong SEO means your tutorial can rank for years. Submitting to publications like "Better Programming", "The Startup", or "UX Collective" can reach tens of thousands of readers.
+
+Write an accessible, engaging tutorial "How I [ACHIEVED OUTCOME] in Minutes Using [YOUR ACTOR] (Step-by-Step)" (1,500-2,200 words). Create or log into your Medium account, then publish the article. Use all 5 available tags strategically.
+
+Take a story-driven approach with personal context. Write in first person, use simple jargon-free language, and make readers feel "I can do this too." Focus on the outcome and value, not technical complexity.
+
+
+
+### Create a "How to use [Actor]" tutorial for LinkedIn
+
+LinkedIn tutorials reach professionals, decision-makers, and business users who value productivity and efficiency. LinkedIn articles have strong SEO and professional credibility. They're perfect for tutorials focused on business outcomes, time-saving, or solving professional challenges.
+
+Write a professional "How to [ACHIEVE BUSINESS OUTCOME] in [TIME] Using [YOUR ACTOR]: A Professional Guide" tutorial (1,400-2,000 words). Publish it as a LinkedIn Article using the "Write article" feature. After publishing, share the article in a regular LinkedIn post with an engaging business-focused intro.
+
+Use professional, consultative tone focused on business value. Emphasize time savings, efficiency, and ROI. Include sections on business case, measuring success, professional best practices, and real-world business applications. Address common professional questions about security, cost, reliability, and team adoption.
+
+
+
+---
+
+## GitHub and developer resources
+
+### Create a GitHub repository with examples
+
+GitHub repos rank well in search and are developer-friendly. A repo with usage examples, tutorials, or integration guides makes it easier for others to adopt and reference your Actor.
+
+Create a GitHub repo with code examples, integration guides, or sample projects using your Actor. Include a comprehensive README with use cases, code snippets, and links to your Actor.
+
+Your README should include: project title with badges, short description, key features, quick start guide, installation and setup instructions, usage examples with code snippets, use cases section, configuration options, common questions and troubleshooting, links to Apify Store and documentation, contributing guidelines, and license.
+
+
+
+---
+
+## Quick wins
+
+Simple actions you can take right now with minimal effort but immediate impact:
+
+- Share your launch on your personal social media accounts (Twitter, LinkedIn, Facebook)
+- Post about your new Actor on your personal website or blog
+- Ask friends and colleagues to share
+- Update your email signature to mention your Actor
+- Add the Actor to your portfolio if you're a freelancer on UpWork or Fiverr
+
+### Create a content hub
+
+Create a free Notion page or GitHub README that lists all your Actors and content with links. Share this hub in your Actor description, social profiles, and email signature. This becomes your content portfolio and makes it easy for people to find all your work.
diff --git a/sources/academy/platform/get_most_of_actors/index.md b/sources/academy/platform/get_most_of_actors/index.md
index bbc58218a..79d1f4ff1 100644
--- a/sources/academy/platform/get_most_of_actors/index.md
+++ b/sources/academy/platform/get_most_of_actors/index.md
@@ -46,12 +46,6 @@ To help you succeed, we've created a comprehensive Actor marketing playbook. You
to="/academy/actor-marketing-playbook/store-basics/how-actor-monetization-works"
smallImage
/>
-
## Actor basics
diff --git a/src/utils/devto-article-prompt.js b/src/utils/devto-article-prompt.js
new file mode 100644
index 000000000..33658738f
--- /dev/null
+++ b/src/utils/devto-article-prompt.js
@@ -0,0 +1,80 @@
+export const DEVTO_ARTICLE_PROMPT = `Create a comprehensive "Best [CATEGORY]" roundup article optimized for dev.to that naturally promotes [YOUR PRODUCT/SERVICE] while providing genuine value to the developer community.
+
+Article requirements:
+- Title: "The [NUMBER] Best [CATEGORY] for Developers in [YEAR]" (dev-focused angle)
+- Word count: 1,500-2,000 words (dev.to readers prefer actionable, scannable content)
+- Include 6-8 solutions total
+- Feature [YOUR PRODUCT/SERVICE] as position #1
+- Friendly, developer-to-developer tone
+- Include pros/cons for each solution
+- Add quick comparison table
+- Include code examples or API snippets where relevant
+
+Your product details:
+- Product name: [YOUR ACTOR NAME]
+- Product URL: [YOUR APIFY STORE URL]
+- Key technical features: [LIST 3-5 FEATURES]
+- Main use cases: [WHAT PROBLEMS IT SOLVES]
+- Tech stack/Integration: [RELEVANT TECHNICAL DETAILS]
+- Readme content: [PASTE HERE YOUR README]
+
+Content structure:
+1. Direct, problem-focused introduction (100-150 words):
+ - Start with the problem developers face
+ - Why you researched these tools
+ - What you'll cover
+
+2. "What I looked for" - clear evaluation criteria developers care about (100 words):
+ - Performance
+ - Ease of integration
+ - Documentation quality
+ - Pricing
+ - Community/support
+
+3. Detailed tool reviews (200-250 words each):
+ - Brief overview and what makes it stand out
+ - Key features (bullet points)
+ - Developer experience highlights
+ - Pros (3-4 specific items)
+ - Cons (2-3 honest drawbacks)
+ - Best for: [use case]
+ - Quick start difficulty: [Easy/Moderate/Complex]
+ - Code example or integration snippet (if applicable)
+
+4. Quick comparison table - focus on specs developers care about
+
+5. "My recommendation" section - which tool for which scenario (150-200 words)
+
+6. Conclusion with TL;DR and call-to-action (100 words)
+
+Writing guidelines:
+- Write like you're advising a fellow developer - casual and helpful
+- Be genuinely objective about all tools
+- Show real strengths of competitors (devs can smell BS)
+- For [YOUR PRODUCT], focus on technical advantages and developer experience
+- Include practical examples and real use cases
+- Use code blocks for any technical examples (specify language for syntax highlighting)
+- Use H2 (##) and H3 (###) markdown headers
+- Keep paragraphs short and scannable
+- Add emoji sparingly where natural (dev.to community uses them but don't overdo it)
+
+Technical credibility:
+- Mention actual testing or experience where possible
+- Include specific metrics (response times, ease of setup, etc.)
+- Reference documentation quality
+- Discuss integration complexity honestly
+- Mention any gotchas or limitations
+
+SEO optimization:
+- Use target keyword "[CATEGORY]" 8-12 times naturally
+- Include variations like "best [category] tools", "[category] for developers", "[category] API"
+- Add semantic keywords related to your technical domain
+- Use keywords in subheadings
+
+dev.to-specific elements:
+- Suggest 4 relevant tags (most important to least, e.g., #webdev, #api, #tools, #productivity)
+- Include a cover image description/suggestion
+- Write an engaging first paragraph that shows up in feed previews
+- Add a brief "Discussion prompt" at the end to encourage comments (e.g., "Which tool do you use? Let me know in the comments!")
+
+Please generate the complete article now in markdown format with proper heading hierarchy.`;
diff --git a/src/utils/devto-tutorial-prompt.js b/src/utils/devto-tutorial-prompt.js
new file mode 100644
index 000000000..5391b3338
--- /dev/null
+++ b/src/utils/devto-tutorial-prompt.js
@@ -0,0 +1,140 @@
+export const DEVTO_TUTORIAL_PROMPT = `Create a step-by-step tutorial showing developers how to use my Apify Actor to achieve [SPECIFIC OUTCOME], optimized for dev.to.
+
+Tutorial Requirements:
+- Title: "How to [ACHIEVE SPECIFIC OUTCOME] with [YOUR ACTOR NAME]" (clear, action-oriented)
+- Word count: 1,200-2,000 words (thorough but scannable)
+- Step-by-step format walking through using the Actor
+- Include screenshots suggestions and what users will see
+- Conversational, developer-to-developer tone
+- Focus on practical usage and configuration
+- Include tips and optional features
+
+Your Actor details:
+- Actor name: [YOUR ACTOR NAME]
+- Actor URL: [YOUR APIFY STORE URL]
+- Actor README: [PASTE YOUR ACTOR'S README OR KEY SECTIONS]
+- Main use case: [WHAT PROBLEM IT SOLVES]
+- Key features: [LIST 3-5 MAIN FEATURES]
+- Output format: [WHAT DATA/RESULTS USERS GET]
+
+Content structure:
+1. Introduction (100-150 words):
+ - Hook: Start with what readers will accomplish
+ - Why this Actor is useful/who it's for
+ - What they'll learn by the end
+ - Time estimate (e.g., "⏱️ This takes about 10 minutes")
+
+2. Prerequisites (50-100 words):
+ - Free Apify account (mention you can sign up with email or GitHub)
+ - Any other requirements
+ - No coding required (if applicable)
+
+3. "What you'll achieve" overview (100-150 words):
+ - Brief description of the end result
+ - What data or outcome they'll get
+ - Example use case
+
+4. Step-by-step tutorial using the Actor:
+
+ Step 1: Access [YOUR ACTOR NAME]
+ - Instructions: "Go to the [Actor Name] page on Apify Store to try it for free."
+ - Mention account creation (email or GitHub)
+ - Explain they'll be redirected to Apify Console
+ - What to expect: "You'll see the Actor's input configuration page"
+ - Screenshot suggestion: Actor page or Console view
+
+ Step 2: Configure [Primary Input/Settings]
+ - Explain the main input field(s) based on your README
+ - Provide specific examples (like "bagel" and "New York")
+ - Explain what the Actor will do with this input
+ - Show different options if your Actor has multiple input methods
+ - Tips for getting better results
+ - Screenshot suggestion: Input configuration
+
+ Step 3: [Additional Configuration - if applicable]
+ - Explain optional settings or advanced features
+ - When and why to use each option
+ - Examples of different configurations
+ - Best practices from your experience
+ - Screenshot suggestion: Advanced settings panel
+
+ Step 4: Run the Actor
+ - Click "Start" or "Run" button
+ - What happens: Status changes to "Running"
+ - How long it typically takes
+ - What's happening behind the scenes (briefly)
+ - "⚠️ Tip: You can leave the page and come back - the run will continue"
+
+ Step 5: View and download results
+ - Navigate to Storage tab or Results
+ - Preview the data
+ - Explain the data structure/fields
+ - Available export formats (JSON, CSV, Excel, etc.)
+ - How to filter or select specific data
+ - Screenshot suggestion: Results page with data
+
+ [Add more steps if your Actor has additional features]
+
+5. "Understanding your results" (150-200 words):
+ - Explain what each key field means
+ - How to interpret the data
+ - Example of actual output
+ - Common questions about results
+
+6. "Pro tips and advanced usage" (150-200 words):
+ - 3-5 tips for getting better results
+ - How to optimize for speed or cost
+ - Advanced configuration options
+ - Integration possibilities (API, webhooks, etc.)
+ - Common use cases from users
+
+7. "Troubleshooting common issues" (100-150 words):
+ - 2-3 common problems and solutions
+ - Where to check for errors
+ - How to get support
+
+8. "Next steps" (50-100 words):
+ - How to automate or schedule runs
+ - Integration ideas
+ - Link to documentation
+ - Encouragement to experiment
+
+Writing guidelines:
+- Write like you're helping a friend get started
+- Use "we" and "let's" language
+- Be encouraging and supportive
+- Explain what users will see at each step
+- Use bullet points for options or lists
+- Include emoji sparingly for visual breaks (✅, 🚀, ⚠️, 💡)
+- Format Actor/button names in bold
+- Use > quote blocks for important notes
+- Keep paragraphs short and scannable
+
+Screenshot guidance:
+- Suggest specific screenshots for each major step
+- Describe what should be visible in each screenshot
+- Example: "Screenshot showing the input form with 'bagel' entered in search field"
+- Mention UI elements to highlight (buttons, fields, tabs)
+
+Actor-specific details:
+- Use actual field names from your Actor's input schema
+- Reference specific features from your README
+- Include real example inputs that work well
+- Mention any enrichment features or add-ons
+- Explain pricing tier differences if relevant
+- Link to Actor documentation for deep dives
+
+SEO optimization:
+- Use "how to [achieve outcome]" in title and 3-5 times in content
+- Include "[Actor name] tutorial", "[Actor name] guide"
+- Use problem-related keywords (what your Actor solves)
+- Mention "Apify" 3-5 times naturally
+
+dev.to-specific elements:
+- Suggest 4 tags (e.g., #tutorial, #automation, #webscraping, #api)
+- Write a compelling first paragraph for feed preview
+- Include a discussion prompt at end: "What are you planning to scrape? Drop a comment! 💬"
+- Suggest a cover image concept (your Actor in action or logo)
+- Add liquid tag suggestions if relevant ({% link %}, {% github %})
+
+Please generate the complete tutorial now in markdown format, based on the Actor's README, with clear steps that walk users through the entire process from accessing the Actor to downloading results.`;
diff --git a/src/utils/github-readme-prompt.js b/src/utils/github-readme-prompt.js
new file mode 100644
index 000000000..d8791ffe8
--- /dev/null
+++ b/src/utils/github-readme-prompt.js
@@ -0,0 +1,28 @@
+export const GITHUB_README_PROMPT = `Create a comprehensive README.md for my Actor's GitHub example repository.
+
+Actor details:
+- Name: [YOUR ACTOR NAME]
+- Purpose: [WHAT IT DOES]
+- Main use cases: [LIST 3-5 USE CASES]
+- Apify Store link: [URL]
+
+README structure:
+1. Project title with badges (build status, version, etc.)
+2. Short description (1-2 sentences)
+3. Key features (bullet points)
+4. Quick start guide
+5. Installation/Setup
+6. Usage examples (3-5 code snippets)
+7. Use cases section
+8. Configuration options
+9. Common questions/troubleshooting
+10. Links (Apify Store, documentation, support)
+11. Contributing guidelines
+12. License
+
+Style:
+- Clear and scannable
+- Include code blocks with syntax highlighting
+- Add emojis for sections where appropriate
+- Professional but friendly tone
+- Emphasize ease of use`;
diff --git a/src/utils/hashnode-article-prompt.js b/src/utils/hashnode-article-prompt.js
new file mode 100644
index 000000000..2c16dc3be
--- /dev/null
+++ b/src/utils/hashnode-article-prompt.js
@@ -0,0 +1,95 @@
+export const HASHNODE_ARTICLE_PROMPT = `Create a comprehensive "Best [CATEGORY]" roundup article optimized for Hashnode that naturally promotes [YOUR PRODUCT/SERVICE] while providing genuine technical value to developers.
+
+Article requirements:
+- Title: "Best [CATEGORY] for [SPECIFIC USE CASE]: A Developer's Guide [YEAR]" (technical angle)
+- Word count: 1,500-2,000 words (Hashnode readers appreciate depth but value clarity)
+- Include 6-8 solutions total
+- Feature [YOUR PRODUCT/SERVICE] as position #1
+- Clear, technical but accessible tone
+- Include pros/cons for each solution
+- Add detailed comparison table
+- Include architecture/workflow diagrams suggestions where relevant
+
+Your product details:
+- Product name: [YOUR ACTOR NAME]
+- Product URL: [YOUR APIFY STORE URL]
+- Technical architecture: [HOW IT WORKS]
+- Key features: [LIST 3-5 TECHNICAL FEATURES]
+- Integration options: [APIs, SDKs, etc.]
+- Main use cases: [PROBLEMS IT SOLVES]
+- Readme content: [PASTE HERE YOUR README]
+
+Content Structure:
+1. Clear, technical introduction (150-200 words):
+ - The specific problem/challenge
+ - Why it matters to developers
+ - What criteria you used for evaluation
+ - What readers will learn
+
+2. "Understanding [CATEGORY]" - brief technical context if needed (100-150 words)
+
+3. "Evaluation criteria" - what developers should consider (150 words):
+ - Technical capabilities
+ - Performance & scalability
+ - Developer experience
+ - Documentation & support
+ - Pricing & value
+
+4. Detailed tool analysis (250-300 words each):
+ - Overview and core functionality
+ - Technical approach/architecture (briefly)
+ - Key features with technical details
+ - Strengths (3-4 items with specifics)
+ - Limitations (2-3 honest cons)
+ - Ideal use cases
+ - Getting started complexity
+ - Integration examples or code snippet (where relevant)
+ - Pricing structure
+
+5. Comprehensive comparison table - include technical specs
+
+6. "Decision framework" - help readers choose based on their needs (200-250 words)
+
+7. Conclusion with key takeaways and next steps (100-150 words)
+
+Writing guidelines:
+- Write with technical authority but remain accessible
+- Be thoroughly objective and fair to all solutions
+- Show genuine strengths of each tool with specific examples
+- For [YOUR PRODUCT], emphasize technical innovation and practical benefits
+- Include real-world scenarios and use cases
+- Use clear code blocks with proper language specification
+- Use H2 (##) and H3 (###) markdown headers consistently
+- Break up text with relevant visual suggestions (architecture diagrams, workflow charts)
+- Keep paragraphs focused and well-structured
+
+Technical depth:
+- Discuss technical implementation approaches
+- Mention performance characteristics where relevant
+- Compare API design or interface quality
+- Reference documentation quality and completeness
+- Discuss scalability and limitations honestly
+- Include actual examples from experience where possible
+
+SEO optimization:
+- Use target keyword "[CATEGORY]" 10-12 times naturally
+- Include long-tail variations like "best [category] for [use case]"
+- Add semantic technical keywords related to your domain
+- Use keywords strategically in headers
+- Include alternative phrasing that developers might search for
+
+Hashnode-specific elements:
+- Suggest 5-6 relevant tags for Hashnode (technical and general)
+- Write a compelling subtitle/brief description (under 160 characters)
+- Suggest a cover image concept (technical/professional)
+- Include a "TL;DR" section at the top after the intro (3-4 bullet points)
+- Add a "What's your experience?" prompt at the end to encourage discussion
+- Mention if this could be part of a series (e.g., "This is part 1 of my [CATEGORY] series")
+
+Code examples:
+- Include at least 1-2 code snippets showing integration or usage
+- Use proper markdown code blocks with language specification
+- Keep code examples practical and copy-pasteable
+- Add comments in code to explain key parts
+
+Please generate the complete article now in clean markdown format with proper structure.`;
diff --git a/src/utils/hashnode-tutorial-prompt.js b/src/utils/hashnode-tutorial-prompt.js
new file mode 100644
index 000000000..5fac66d78
--- /dev/null
+++ b/src/utils/hashnode-tutorial-prompt.js
@@ -0,0 +1,212 @@
+export const HASHNODE_TUTORIAL_PROMPT = `Create a comprehensive technical tutorial showing developers how to use my Apify Actor to achieve [SPECIFIC OUTCOME], optimized for Hashnode's technical audience.
+
+Tutorial requirements:
+- Title: "Complete Guide: How to [ACHIEVE OUTCOME] Using [YOUR ACTOR NAME]" (comprehensive angle)
+- Word count: 1,800-2,500 words (Hashnode readers appreciate thorough, detailed content)
+- Detailed step-by-step walkthrough of using the Actor
+- Include technical explanations and best practices
+- Multiple screenshots and visual guidance
+- Professional, technical but accessible tone
+- Include advanced usage and API integration examples
+
+Your Actor details:
+- Actor name: [YOUR ACTOR NAME]
+- Actor URL: [YOUR APIFY STORE URL]
+- Actor README: [PASTE YOUR ACTOR'S README OR KEY SECTIONS]
+- Technical capabilities: [WHAT IT DOES TECHNICALLY]
+- Main use case: [PRIMARY PROBLEM IT SOLVES]
+- Output format and structure: [DATA FORMAT DETAILS]
+
+Content structure:
+1. Introduction (150-200 words):
+ - What this tutorial covers
+ - The use case and why it matters
+ - What readers will accomplish
+ - Technical prerequisites (minimal)
+ - Estimated time to complete
+
+2. TL;DR section (100 words):
+ - Quick summary: "In this tutorial, you'll learn to..."
+ - Key steps overview
+ - Link to Actor
+ - Expected outcome
+
+3. Prerequisites and setup (100-150 words):
+ - Apify account (free tier works)
+ - How to sign up (email or GitHub)
+ - What is Apify Console (brief explanation)
+ - Any other requirements
+ - Link to Apify documentation
+
+4. Understanding [YOUR ACTOR] (150-200 words):
+ - What the Actor does (technical overview)
+ - How it works behind the scenes
+ - Key capabilities and features
+ - Use cases and applications
+ - Advantages over alternatives
+ - Limitations to be aware of
+
+5. Step-by-step guide to using [YOUR ACTOR]:
+
+ Step 1: Accessing the Actor
+ - Navigate to the [Actor Name] page on Apify Store
+ - Create account or sign in
+ - Understanding the Actor page (features, pricing, reviews)
+ - Click the "Try for free" button
+ - What happens: Redirect to Apify Console
+ - Screenshot: Actor Store page and Console
+
+ Step 2: Configuring input parameters
+ - Overview of the input form/configuration
+ - Explanation of each input field based on README:
+ Primary input field (purpose, format, examples)
+ Location or context fields (if applicable)
+ Optional parameters and when to use them
+ - Provide 2-3 complete example configurations
+ - Screenshot: Input configuration with examples filled in
+ - Best practices for input configuration
+
+ Step 3: Advanced configuration (if applicable)
+ - Advanced settings and options from README
+ - When and why to use advanced features
+ - Performance vs. thoroughness trade-offs
+ - Cost optimization tips
+ - Example: Different configurations for different use cases
+ - Screenshot: Advanced settings panel
+
+ Step 4: Optional enrichment features
+ - Explanation of any enrichment add-ons (from README)
+ - What additional data they provide
+ - Pricing tier considerations
+ - When to use enrichment features
+ - How to enable and configure them
+ - Example use cases for enriched data
+
+ Step 5: Running the Actor
+ - Click "Start" or "Run" button
+ - Understanding the run lifecycle (Running → Succeeded/Failed)
+ - What to expect: timing, resource usage
+ - How to monitor the run (logs, status)
+ - Can you close the browser? (Yes, runs continue)
+ - Screenshot: Run status page
+
+ Step 6: Examining the results
+ - Navigate to Storage or Results tab
+ - Understanding the data structure
+ - Explanation of output fields (from README)
+ - Preview the dataset in Console
+ - How data is organized
+ - Data quality and completeness
+ - Screenshot: Results preview with annotations
+
+ Step 7: Downloading and exporting data
+ - Export options (JSON, CSV, Excel, XML, RSS)
+ - How to select specific fields or data subsets
+ - Download vs. API access
+ - Best format for your use case
+ - Screenshot: Export options dialog
+
+ [Add more steps if your Actor has additional features or workflows]
+
+6. Working with the API (200-300 words):
+ - How to run the Actor via API
+ - Code example: Starting a run (JavaScript/Python)
+ - Code example: Retrieving results
+ - Authentication and API tokens
+ - Webhook integration possibilities
+ - Scheduling and automation
+ - Error handling
+ - Rate limits and best practices
+
+7. Advanced usage patterns (200-250 words):
+ - Batch processing multiple queries
+ - Integrating with other tools (Zapier, Make, etc.)
+ - Setting up scheduled runs
+ - Monitoring and alerting
+ - Cost optimization strategies
+ - Scaling considerations
+
+8. Understanding your data (150-200 words):
+ - Detailed explanation of output fields
+ - How to interpret the results
+ - Data quality indicators
+ - Common data patterns
+ - Example analysis or use case
+
+9. Troubleshooting guide (150-200 words):
+ - Common errors and solutions
+ - How to read logs
+ - Performance issues
+ - Data quality problems
+ - Where to get help (Apify Discord, support)
+
+10. Best practices (100-150 words):
+ - Configuration tips
+ - Cost efficiency
+ - Data freshness considerations
+ - Rate limiting and politeness
+ - Error handling
+
+11. Conclusion and next steps (100 words):
+ - Recap what was accomplished
+ - Additional resources
+ - Link to Actor documentation
+ - Invitation to connect or ask questions
+
+Writing guidelines:
+- Write with technical authority
+- Be thorough but maintain clarity
+- Use proper H2 (##) and H3 (###) markdown headers
+- Include inline code formatting for field names and buttons
+- Use code blocks for API examples with proper syntax highlighting
+- Keep paragraphs focused (4-6 sentences)
+- Add visual suggestions throughout
+- Link to relevant Apify documentation
+
+Actor-specific details:
+- Use exact field names from your Actor's input schema
+- Reference all features mentioned in README
+- Include actual example inputs with expected outputs
+- Explain any technical constraints or limitations
+- Mention supported data sources or formats
+- Discuss performance characteristics
+- Include pricing considerations if relevant
+
+Screenshot guidance:
+- Suggest 6-8 specific screenshots with descriptions
+- Annotate what users should focus on
+- Show the complete workflow visually
+- Include before/after or input/output examples
+- Suggest callouts or highlights for important UI elements
+
+Code examples (if including API usage):
+- Provide working code samples
+- Include error handling
+- Add comments explaining key parts
+- Show both async and sync patterns if applicable
+- Use realistic variable names
+- Format: \`\`\`javascript or \`\`\`python
+
+SEO optimization:
+- Use "how to [achieve outcome]" naturally 4-6 times
+- Include "[Actor name] tutorial", "complete guide to [Actor]"
+- Use technical keywords related to your domain
+- Include "Apify Actor" 4-6 times naturally
+- Use semantic keywords in subheadings
+
+Hashnode-specific elements:
+- Suggest 5-6 relevant tags (technical and general)
+- Write compelling subtitle/meta description (under 160 characters)
+- Suggest professional cover image concept
+- Note: "Use H2/H3 headers for auto-generated table of contents"
+- Include author bio at end (your expertise with Apify/this domain)
+- Add call-to-action: "Try [Actor Name] yourself and let me know what you build!"
+- Suggest if this could be part of a series
+
+Additional elements:
+- Include a "Resources" section with relevant links
+- Link to Actor documentation, Apify docs, related tutorials
+- Consider adding a "What's next?" section with related topics
+- Mention community resources (Apify Discord, forum)
+
+Please generate the complete tutorial now in markdown format, based on the Actor's README, with comprehensive steps that guide users through the entire process including basic usage, advanced features, and API integration.`;
diff --git a/src/utils/linkedin-article-prompt.js b/src/utils/linkedin-article-prompt.js
new file mode 100644
index 000000000..81fc11717
--- /dev/null
+++ b/src/utils/linkedin-article-prompt.js
@@ -0,0 +1,98 @@
+export const LINKEDIN_ARTICLE_PROMPT = `Create a comprehensive "Best [CATEGORY]" roundup article optimized for LinkedIn that naturally promotes [YOUR PRODUCT/SERVICE] while providing business value to professional readers.
+
+Article requirements:
+- Title: "The Best [CATEGORY] for [BUSINESS OUTCOME] in [YEAR]" (business-focused angle)
+- Word count: 1,200-1,800 words (LinkedIn readers prefer focused, professional content)
+- Include 5-7 solutions total (slightly fewer, more focused)
+- Feature [YOUR PRODUCT/SERVICE] as position #1 or #2
+- Professional, authoritative but accessible tone
+- Include pros/cons focused on business impact
+- Add comparison table with business-relevant metrics
+- Emphasize ROI, efficiency, and business outcomes
+
+Your product details:
+- Product name: [YOUR ACTOR NAME]
+- Product URL: [YOUR APIFY STORE URL]
+- Key business benefits: [HOW IT SAVES TIME/MONEY/RESOURCES]
+- Main use cases: [BUSINESS PROBLEMS IT SOLVES]
+- Target users: [ROLES/DEPARTMENTS WHO BENEFIT]
+- ROI/Value proposition: [MEASURABLE BENEFITS]
+- Readme content: [PASTE HERE YOUR README]
+
+Content structure:
+1. Professional hook and introduction (150-200 words):
+ - Start with a business challenge or opportunity
+ - Establish credibility (your experience/background)
+ - Why this matters for businesses now
+ - What decision-makers will learn
+
+2. "Why [CATEGORY] matters for your business" (150-200 words):
+ - Business impact and ROI potential
+ - Current market trends
+ - Risk of not having the right solution
+
+3. "What we evaluated" - business-focused criteria (100-150 words):
+ - Business value and ROI
+ - Ease of implementation
+ - Scalability
+ - Support and reliability
+ - Total cost of ownership
+
+4. Detailed solution analysis (200-250 words each):
+ - Executive summary of what it does
+ - Key capabilities from a business perspective
+ - Business benefits (3-4 items focusing on outcomes)
+ - Considerations (2-3 items - challenges or limitations)
+ - Best suited for: [company size/industry/use case]
+ - Pricing and value assessment
+ - Implementation complexity and timeline
+ - ROI potential or success metrics
+
+5. Comparison table - focus on business metrics (pricing, implementation time, support, scalability)
+
+6. "Choosing the right solution for your team" (200-250 words):
+ - Decision framework based on company size, needs, budget
+ - Questions to ask before choosing
+
+7. Professional conclusion and call-to-action (100-150 words)
+
+Writing guidelines:
+- Write in a professional, consultative tone (you're advising peers)
+- Be objective and business-focused, not salesy
+- Acknowledge real strengths of all solutions from a business perspective
+- For [YOUR PRODUCT], emphasize business value, efficiency gains, and practical benefits
+- Use concrete examples and real business scenarios
+- Include data, metrics, or percentages where possible (even estimates)
+- Use clear H2 headers (written in title case)
+- Keep paragraphs short for mobile reading (2-4 sentences)
+- Write in second person ("your business", "your team") to create connection
+
+Business focus:
+- Emphasize time savings and efficiency
+- Discuss total cost of ownership, not just price
+- Mention integration with existing workflows
+- Consider change management and adoption
+- Discuss support and reliability
+- Include scalability considerations
+- Reference security or compliance if relevant
+
+SEO optimization:
+- Use target keyword "[CATEGORY]" 8-10 times naturally
+- Include business-focused variations: "best [category] for businesses", "[category] solutions", "enterprise [category]"
+- Add semantic keywords related to business outcomes
+- Use keywords in subheadings professionally
+
+LinkedIn-specific elements:
+- Write a compelling opening line that hooks professionals immediately
+- Suggest a professional cover image concept (clean, business-focused)
+- Include 3-5 relevant hashtags to add at the end (e.g., #ProductivityTools #BusinessAutomation #TechStack)
+- Add a professional bio section at the very end (2-3 sentences about who you are and your expertise)
+- Include a clear call-to-action that's professional (e.g., "What tools is your team using? Share in the comments" or "Connect with me to discuss [topic]")
+- Suggest a post caption for when sharing the article (50-100 words, engaging hook)
+
+Tone examples:
+- Instead of "This tool is awesome" → "This solution delivers measurable efficiency gains"
+- Instead of "Super easy to use" → "Minimal learning curve for team adoption"
+- Instead of "Cheap pricing" → "Cost-effective solution for growing teams"
+
+Please generate the complete article now with clear professional structure and business focus.`;
diff --git a/src/utils/linkedin-post-prompt.js b/src/utils/linkedin-post-prompt.js
new file mode 100644
index 000000000..f8f7db552
--- /dev/null
+++ b/src/utils/linkedin-post-prompt.js
@@ -0,0 +1,131 @@
+export const LINKEDIN_POST_PROMPT = `Create 5 engaging LinkedIn posts to promote my Apify Actor, each with a different angle and hook. Each post should include a demo video concept.
+
+Actor details:
+- Actor name: [YOUR ACTOR NAME]
+- Actor URL: [YOUR APIFY STORE URL]
+- What it does: [BRIEF DESCRIPTION]
+- Main business benefit: [KEY VALUE PROPOSITION - time saved, efficiency gained, etc.]
+- Target audience: [WHO USES THIS - sales teams, marketers, researchers, etc.]
+- Typical time savings: [HOW MUCH TIME IT SAVES vs. MANUAL APPROACH]
+
+For each post, create:
+1. An opening hook (1-2 punchy sentences that stop the scroll)
+2. The problem description (2-3 sentences about the manual pain)
+3. The solution introduction (2-3 sentences about your Actor)
+4. Results/impact (2-3 sentences with specific metrics - numbers are key here)
+5. Call-to-action question (engaging, encourages comments)
+6. 3-5 relevant hashtags
+7. Demo video concept (what to show in 30-90 seconds)
+
+Post variation angles:
+
+Post #1: "Before/After" Transformation
+- Focus on the dramatic change in workflow
+- Emphasize time saved with specific numbers
+- Personal story angle: "I used to... now I..."
+- Hook example: "I spent 6 hours doing [task] manually yesterday. Today? 8 minutes."
+
+Post #2: "Problem/Agitation/Solution"
+- Start with a frustrating problem everyone relates to
+- Agitate the pain point (cost, frustration, wasted time)
+- Present your Actor as the solution
+- Hook example: "Your team is wasting 10+ hours per week on [task]. Here's what it's actually costing you..."
+
+Post #3: "Behind-the-scenes/Building in public"
+- Share why you built this Actor
+- The problem you personally faced
+- Invite others who have the same problem
+- Hook example: "I built [Actor] because I was tired of [problem]. Turns out, I'm not alone."
+
+Post #4: "Results/Case study"
+- Lead with impressive results or metrics
+- Show business impact
+- Make it about ROI and efficiency
+- Hook example: "Saved 15 hours last week using automation. Here's exactly how ⬇️"
+
+Post #5: "Contrarian/Hot take"
+- Challenge conventional wisdom about the task
+- Position your Actor as the smarter approach
+- Hook example: "Stop doing [task] manually. It's 2025. Here's the better way:"
+
+Writing guidelines:
+- Write in the first person for authenticity
+- Use short paragraphs (1-3 sentences each)
+- Be conversational and professional, not salesy
+- Include specific numbers and metrics
+- Focus on business outcomes, not technical features
+- Use line breaks for readability
+- Keep the total post under 1,300 characters for optimal engagement
+- Make the hook compelling enough to stop mid-scroll
+
+Professional tone:
+- Confident but not arrogant
+- Helpful, not pushy
+- Data-driven, not vague
+- Relatable, not corporate-speak
+- Examples:
+ Instead of: "This tool is amazing!" → "This approach cut my research time by 75%"
+ Instead of: "Try my Actor!" → "Here's how I automated [task]:"
+ Instead of: "It's super easy!" → "The setup takes less than 10 minutes"
+
+Call-to-action variations:
+- "What manual tasks are eating up your team's time?"
+- "How are you currently handling [this process]?"
+- "Anyone else spending too much time on [task]?"
+- "What would you do with an extra 10 hours per week?"
+- "Is your team still doing this manually?"
+
+Hashtag strategy:
+Mix these types (3-5 per post):
+- Industry-specific: #SaaS #MarketResearch #SalesOps
+- Outcome-focused: #Productivity #Efficiency #Automation
+- Broad professional: #BusinessGrowth #ProfessionalDevelopment
+- Tool/platform: #NoCode #DataAnalysis #WebScraping
+
+Demo video concepts:
+- Post #1: Split-screen showing manual process vs. automated
+- Post #2: Screen recording of results with on-screen metrics
+- Post #3: Quick walkthrough of the Actor in action
+- Post #4: Dashboard showing time/cost savings
+- Post #5: Side-by-side comparison of old way vs. new way
+
+Video-specific notes:
+- First 3 seconds must be compelling (show end result immediately)
+- Add text overlays with key metrics/benefits
+- Include captions (most LinkedIn videos watched without sound)
+- End with clear next step or URL
+- Keep it professional but authentic
+
+Additional elements for each post:
+- Suggest optimal posting time (e.g., "Tuesday 9 AM" or "Thursday lunch")
+- Note whether to tag anyone relevant (but only if genuinely relevant)
+- First comment suggestion (where to put the Actor link)
+- Engagement strategy (how to respond to comments)
+
+Format each post clearly:
+---
+POST #1: [Angle Name]
+
+Hook:
+[Opening 1-2 sentences]
+
+Body:
+[Main content with problem/solution/results]
+
+CTA:
+[Engaging question]
+
+Hashtags:
+[3-5 hashtags]
+
+Demo Video Concept:
+[What to show in 30-90 seconds]
+
+First Comment (with link):
+[Suggested comment to post immediately after, including Actor link]
+
+Best Time to Post:
+[Day and time recommendation]
+---
+
+Please generate all 5 complete LinkedIn posts now, each with a unique angle that will resonate with my target professional audience.`;
diff --git a/src/utils/linkedin-tutorial-prompt.js b/src/utils/linkedin-tutorial-prompt.js
new file mode 100644
index 000000000..87a5ff209
--- /dev/null
+++ b/src/utils/linkedin-tutorial-prompt.js
@@ -0,0 +1,277 @@
+export const LINKEDIN_TUTORIAL_PROMPT = `Create a professional step-by-step tutorial showing business users how to use my Apify Actor to achieve [SPECIFIC OUTCOME], optimized for LinkedIn's professional audience.
+
+Tutorial requirements:
+- Title: "How to [ACHIEVE BUSINESS OUTCOME] in [TIME] Using [YOUR ACTOR]: A Professional Guide"
+- Word count: 1,400-2,000 words
+- Professional, consultative tone focused on business value
+- Step-by-step walkthrough of using the Actor with business context
+- Minimal technical jargon, maximum clarity
+- Emphasize time savings, efficiency, and ROI
+- Include real business scenarios
+
+Your Actor details:
+- Actor name: [YOUR ACTOR NAME]
+- Actor URL: [YOUR APIFY STORE URL]
+- Actor README: [PASTE KEY SECTIONS OF YOUR README]
+- Business problem it solves: [WHAT CHALLENGE IT ADDRESSES]
+- Time/money it saves: [QUANTIFIABLE BENEFITS]
+- Target users: [JOB ROLES/DEPARTMENTS]
+- Main use case: [SPECIFIC BUSINESS SCENARIO]
+
+Content structure:
+1. Professional introduction (150-200 words):
+ - Start with a common business challenge your audience faces
+ - Establish your credibility (your role, why you're qualified to guide them)
+ - The cost of doing this task manually (time, money, opportunity cost)
+ - What readers will accomplish by following this guide
+ - Time investment required (be specific: "15 minutes of setup")
+ - The business outcome they'll achieve
+
+2. The business case (150-200 words):
+ - Why this task matters for professionals
+ - Typical time wasted on manual approaches (e.g., "Most teams spend 5-10 hours per week on this")
+ - Cost implications (calculate hourly rate × hours saved)
+ - Competitive advantages of automation
+ - Which roles or departments benefit most
+ - Expected ROI or efficiency gain
+
+3. What You'll Need (100-150 words):
+ - Free Apify account (explain what Apify is: "professional-grade automation platform")
+ - Simple sign-up process (business email works, takes 1 minute)
+ - Time required: "[X] minutes to set up, then automated"
+ - No technical expertise required (emphasize this for confidence)
+ - Cost structure: Free tier capabilities vs. paid options (be transparent)
+ - What you'll have at the end
+
+4. Understanding the solution (100-150 words):
+ - What [Your Actor] does in business terms (not technical jargon)
+ - Why it's effective for this specific use case
+ - How it fits into existing business workflows
+ - Reliability and scalability considerations
+ - Security or compliance notes (if relevant to business users)
+
+5. Step-by-step professional guide (900-1,200 words):
+
+Step 1: Access [YOUR ACTOR NAME]
+(150-200 words)
+- "First, navigate to the [Actor Name] page on Apify Store"
+- Explain what Apify Store is: "a marketplace of professional automation tools"
+- Click "Try for free" or "Sign up"
+- Account creation options: business email or GitHub (takes 1 minute)
+- You'll be redirected to Apify Console—your automation workspace
+- What you see: Professional interface for managing automations
+- Business context: "You're now accessing enterprise-grade tools used by companies worldwide"
+- Screenshot suggestion: Actor Store page with professional appearance
+
+Step 2: Configure Your Parameters
+(200-250 words)
+- Overview: "Now you'll specify what data or outcome you want"
+- Explain the main input fields based on your README in business terms
+- Provide a concrete business example:
+ "For instance, if you're researching market competitors, you might enter..."
+ Use a realistic professional scenario
+- Walk through each key field:
+ What it's for in business terms
+ Example input that works well
+ Why this matters for your outcome
+- Mention any location or context fields
+- Best practices for business applications: "More specific inputs yield better results"
+- Screenshot suggestion: Input configuration with professional example filled in
+- Time required: "Takes 2-3 minutes to configure"
+
+Step 3: Select optional settings (if applicable)
+(150-200 words)
+- "These advanced options let you customize your results"
+- Explain optional settings from your README in business language
+- When to use each setting (provide business scenarios)
+- Cost-benefit consideration: "For most professional use cases, defaults work well"
+- If your Actor has filters or refinement options, explain their business value
+- Professional tip from your experience
+- Screenshot suggestion: Advanced settings panel
+
+Step 4: Enable enrichment features (if your Actor has them)
+(150-200 words)
+- Explain any enrichment add-ons from README in business terms
+- What additional business intelligence they provide
+- Example: "Contact enrichment adds email addresses and phone numbers, saving hours of manual research"
+- Pricing tier considerations (be transparent)
+- ROI analysis: When is the extra cost worth it?
+- How to enable these features
+- Use case examples for different roles
+- "Many professionals find this pays for itself in time saved"
+
+Step 5: Run the process
+(100-150 words)
+- "Once configured, click the Start button"
+- What happens: Status changes to "Running"
+- Typical duration (set clear expectations: "Usually completes in 3-5 minutes")
+- "You can close your browser—the process continues in the background"
+- Where to see progress if they want to monitor
+- Professional reassurance: Reliable, secure processing
+- "Feel free to continue with other work while this runs"
+- Screenshot suggestion: Run status page showing progress
+
+Step 6: Review Your Results
+(200-250 words)
+- "Once complete, navigate to the Storage tab or click Results"
+- What you'll see: Preview of your data
+- Explanation of the output structure based on README
+- Key fields and what they mean in business terms
+- Data quality and completeness you can expect
+- Example: "You'll see company names, contact information, locations, and other relevant details"
+- How this data helps with business decisions
+- "This is the intelligence that would have taken hours to gather manually"
+- Screenshot suggestion: Results preview with data visible
+
+Step 7: Export for Business Use
+(150-200 words)
+- Available export formats: Excel, CSV, JSON, XML
+- "For most business users, Excel is the most practical format"
+- How to select specific fields or data subsets you need
+- Click Export and choose your format
+- Where the file downloads
+- "You now have clean, structured data ready for analysis or presentation"
+- Integration options with existing tools (CRM, spreadsheets, BI tools)
+- Screenshot suggestion: Export dialog with format options
+
+6. Measuring Success (150-200 words):
+ - Key metrics to track for this task
+ - Time saved per use (be specific: "What took 4 hours now takes 10 minutes")
+ - Cost savings calculation (your hourly rate × time saved)
+ - Quality improvements over manual methods
+ - How to demonstrate ROI to stakeholders or leadership
+ - Benchmarks: "Most professionals complete this process in under 15 minutes"
+ - Long-term value: "Multiply this by weekly or monthly usage"
+
+7. Professional Best Practices (200-250 words):
+ - Insights from your experience using this Actor
+ - How to integrate into team workflows
+ - Setting up recurring runs or schedules (mention Apify's scheduling features)
+ - Maintaining data quality and accuracy
+ - Cost optimization for regular use
+ - Compliance or data handling considerations (if relevant)
+ - Training team members: "It's intuitive enough that most colleagues can learn in minutes"
+ - Scaling as needs grow
+ - When to use free tier vs. paid plans
+
+8. Real-World Business Applications (150-200 words):
+ - 3-4 specific professional use cases:
+ Sales teams: [how they can use this]
+ Marketing: [specific application]
+ Research/Analysis: [how it helps]
+ Operations: [efficiency gains]
+ - Industry-specific examples if relevant
+ - Your personal professional use case and results
+ - "I use this weekly for [specific task] and it saves me approximately [X hours]"
+
+9. Common Professional Questions (150-200 words):
+ - Address 4-5 business concerns:
+ "Is my data secure?" (explain Apify's security)
+ "What does regular use cost?" (transparent pricing info)
+ "Can non-technical team members use this?" (yes, emphasize ease)
+ "How reliable is it for business-critical tasks?" (discuss reliability)
+ "Can it integrate with our existing tools?" (mention export options, API)
+ - Clear, reassuring professional answers
+ - Format as Q&A for scannability
+
+10. Next Steps for Your Organization (100-150 words):
+ - How to scale usage across your team
+ - Setting up automation and scheduling for recurring needs
+ - Integration with business intelligence or CRM tools
+ - Building this into standard operating procedures
+ - Where to get support (Apify documentation, support channels)
+ - Resources for team training
+ - "Start with one use case, then expand as you see results"
+
+11. Professional Conclusion (100-150 words):
+ - Recap the business value delivered
+ - Summarize time and cost savings
+ - Competitive advantage gained through automation
+ - Clear next step: "Try [Actor Name] for your own use case"
+ - Professional call-to-action: "What similar challenges is your team facing? Share in the comments."
+ - Offer to connect and discuss applications: "Connect with me to explore how this could work for your specific needs"
+
+Writing guidelines:
+- Use professional, consultative tone (you're advising peers)
+- Address reader as "you" and reference "your team" or "your organization"
+- Be authoritative but approachable
+- Avoid technical jargon—use business language
+- When technical terms are necessary, explain them simply in business context
+- Keep paragraphs short for mobile reading (2-4 sentences)
+- Use subheadings in professional title case
+- Include specific metrics, timeframes, and costs
+- Be concrete about business benefits at every step
+- Write with confidence and expertise
+
+Professional Language Examples:
+- Instead of "It's super easy!" → "The process is straightforward and intuitive"
+- Instead of "This tool rocks!" → "This solution delivers measurable business value"
+- Instead of "Just click here" → "Navigate to the configuration panel"
+- Instead of "It's really cheap" → "Cost-effective for professional use at scale"
+- Instead of "You'll love it!" → "This approach has proven effective for professionals in similar roles"
+
+Actor-specific details to include:
+- Use exact field names from your README, but explain them in business terms
+- Reference all business-relevant features mentioned in README
+- Include realistic professional examples for inputs
+- Explain pricing tiers clearly and honestly
+- Mention any team or enterprise features
+- Discuss data security/compliance if mentioned in README
+- Link naturally to Actor documentation for those who want details
+
+Screenshot Suggestions:
+- Suggest 5-7 professional-quality screenshots
+- Describe what business users should focus on in each
+- Show the complete professional workflow visually
+- Include clean examples of results/data
+- Keep visuals professional and uncluttered
+- Annotate or highlight important UI elements in descriptions
+
+SEO Optimization:
+- Use "how to [business outcome]" naturally 4-6 times throughout
+- Include business keywords: "professional guide," "business automation," "increase efficiency," "save time"
+- Use your Actor name 5-7 times naturally in context
+- Include outcome-focused keywords: "streamline," "automate," "optimize," "productivity"
+- Use professional variations in subheadings
+- Front-load important keywords in title and first paragraphs
+
+LinkedIn-Specific Elements:
+- Write a compelling opening paragraph that shows in feed previews
+- Start with a business pain point that hooks readers
+- Suggest a professional cover image (clean, business-focused, your Actor in action)
+- Include 3-5 relevant hashtags at the end: #Productivity #BusinessAutomation #ProfessionalDevelopment #Efficiency #DataIntelligence
+- Add a professional author bio at the very end (2-3 sentences):
+ Your role and area of expertise
+ Your experience with automation/data/efficiency
+ How you help your professional network
+- Include a professional call-to-action that encourages engagement:
+ "How does your team currently handle [this task]? I'd love to hear your approach in the comments."
+ "Connect with me if you'd like to discuss automation strategies for your organization."
+ "Share this guide with colleagues who could benefit from these efficiency gains."
+- Create a suggested post caption for sharing the article (100-150 words):
+ Professional hook addressing a business pain point
+ Key benefit highlighted (time saved, efficiency gained)
+ Question to encourage engagement
+ 2-3 relevant hashtags
+
+Credibility and trust builders:
+- Include specific time savings metrics ("saves 4 hours per week")
+- Reference professional standards or best practices
+- Mention successful use cases or scenarios
+- Show expertise through strategic insights
+- Acknowledge challenges honestly and professionally
+- Provide business context for every recommendation
+- Use data and percentages where possible ("73% faster than manual approaches")
+
+Business benefits to emphasize throughout:
+- Time savings (quantify specifically)
+- Cost efficiency (calculate real dollars)
+- Quality improvements over manual work
+- Scalability for growing needs
+- Reliability for business-critical tasks
+- Integration with existing tools and workflows
+- Professional support and documentation available
+- Security and compliance (if relevant)
+- Team adoption ease (no technical training needed)
+
+Please generate the complete professional tutorial now, based on the Actor's README. Translate all technical features into clear business benefits. Walk readers through each step of using the Actor with professional context, business examples, and clear value at every stage. Make it feel like expert professional guidance from a trusted colleague.`;
diff --git a/src/utils/medium-article-prompt.js b/src/utils/medium-article-prompt.js
new file mode 100644
index 000000000..b058dc0f7
--- /dev/null
+++ b/src/utils/medium-article-prompt.js
@@ -0,0 +1,60 @@
+export const MEDIUM_ARTICLE_PROMPT = `Create a comprehensive "Best [CATEGORY]" roundup article optimized for Medium that naturally promotes [YOUR PRODUCT/SERVICE] while providing genuine value to readers.
+
+Article requirements:
+- Title: "The [NUMBER] Best [CATEGORY] in [YEAR]" (make it compelling and click-worthy)
+- Word count: 1,800-2,500 words (Medium readers prefer longer, in-depth content)
+- Include 6-8 solutions total
+- Feature [YOUR PRODUCT/SERVICE] as position #1
+- Conversational yet professional tone with personal insights
+- Include pros/cons for each solution
+- Add comparison table
+- Include relevant images or screenshots for each tool (mention where to add them)
+
+Your product details:
+- Product name: [YOUR ACTOR NAME]
+- Product URL: [YOUR APIFY STORE URL]
+- Key features: [LIST 3-5 KEY FEATURES]
+- Main use cases: [WHO IT'S FOR]
+- Readme content: [PASTE HERE YOUR README]
+
+Content structure:
+1. Engaging introduction with a hook - tell a brief story or share a problem scenario (200-300 words)
+2. Why [CATEGORY] matters - paint the bigger picture (150-200 words)
+3. "How I evaluated these tools" - brief methodology that builds trust (100-150 words)
+4. Detailed reviews of each solution (250-350 words each):
+ - What it is and what makes it unique
+ - Key features (3-4 bullet points)
+ - Pros (3-4 items)
+ - Cons (2-3 items - be honest)
+ - Best for: [specific use case]
+ - Pricing overview
+ - Personal take or experience
+5. Comparison table with key features (create a clear table)
+6. "Which one should you choose?" - recommendations for different use cases (200-300 words)
+7. Conclusion with final thoughts and call-to-action (100-150 words)
+
+Writing guidelines:
+- Write in first person - share your perspective and experience
+- Be objective and genuinely fair to all solutions
+- Highlight real strengths of competitors (builds trust)
+- For [YOUR PRODUCT], emphasize unique benefits and specific scenarios where it excels
+- Include specific examples and use cases throughout
+- Use H2 and H3 subheadings for easy scanning
+- Write in a warm, engaging, story-driven style that Medium readers love
+- Add transitional phrases between sections
+- Include a personal anecdote or lesson learned somewhere in the article
+
+SEO optimization:
+- Use the target keyword "[CATEGORY]" 10-15 times naturally throughout
+- Include related keywords like "best", "top", "review", "comparison", "vs", "alternative"
+- Add semantic keywords related to your industry
+- Front-load important keywords in the title and first paragraph
+- Create compelling subheadings with keywords
+
+Medium-specific elements:
+- Suggest 5 strategic tags to use (most relevant to least)
+- Create an engaging subtitle (under 140 characters) that appears under the title
+- Write a compelling opening sentence that hooks readers immediately
+- Suggest 3 relevant Medium publications to submit this to after publishing
+
+Please generate the complete article now with clear section markers.`;
diff --git a/src/utils/medium-tutorial-prompt.js b/src/utils/medium-tutorial-prompt.js
new file mode 100644
index 000000000..5a6bd366d
--- /dev/null
+++ b/src/utils/medium-tutorial-prompt.js
@@ -0,0 +1,220 @@
+export const MEDIUM_TUTORIAL_PROMPT = `Create an accessible, engaging tutorial showing readers how to use my Apify Actor to achieve [SPECIFIC OUTCOME], optimized for Medium's broader audience.
+
+Tutorial requirements:
+- Title: "How I [ACHIEVED OUTCOME] in Minutes Using [YOUR ACTOR] (Step-by-Step)" (personal, outcome-focused)
+- Word count: 1,500-2,200 words (Medium readers prefer narrative, engaging content)
+- Story-driven approach with personal context
+- Clear, visual step-by-step instructions anyone can follow
+- Focus on the outcome and value, not technical complexity
+- Conversational, warm, and encouraging tone
+- Emphasize "no coding required" if applicable
+- Include real results and tangible benefits
+
+Your Actor details:
+- Actor name: [YOUR ACTOR NAME]
+- Actor URL: [YOUR APIFY STORE URL]
+- Actor README: [PASTE RELEVANT SECTIONS OF YOUR README]
+- What it does in simple terms: [NON-TECHNICAL DESCRIPTION]
+- Main benefit/outcome: [WHAT USERS ACHIEVE]
+- Who it's for: [TARGET USERS - BE BROAD]
+- Real-world use case: [RELATABLE PROBLEM IT SOLVES]
+
+Content structure:
+1. Compelling introduction with a hook (200-300 words):
+ - Start with a relatable problem or personal story
+ - Your experience facing this challenge
+ - Traditional approaches and why they fail
+ - The "aha moment" discovering this solution
+ - What readers will learn and achieve
+ - Make it personal and engaging
+
+2. "Why I needed this solution" (150-200 words):
+ - Paint the picture of your challenge
+ - Time wasted with manual approaches
+ - Impact on your work or business
+ - What you were looking for in a solution
+ - Why this Actor was the answer
+
+3. "What you'll need" (100-150 words):
+ - Free Apify account (very simple to create)
+ - Time required (be specific: "about 10 minutes")
+ - No technical skills required (reassure them)
+ - Optional: What you'll do with the data afterward
+ - Total cost: Free tier or pricing info
+
+4. "What you'll accomplish" (100-150 words):
+ - Clear picture of the end result
+ - What data or outcome they'll get
+ - Real-world value of this outcome
+ - Personal example of how you used it
+
+5. Step-by-step guide (1,000-1,300 words):
+ Format as a clear journey with personal insights:
+
+ Step 1: Get started with [YOUR ACTOR NAME]
+ - "First, head over to the [Actor Name] page..."
+ - Creating your free account (use email or GitHub - super easy)
+ - What Apify Console is (explain simply: "your workspace")
+ - What you'll see when you land there
+ - Personal note: "Don't worry, it's much simpler than it looks!"
+ - Screenshot description: Actor page, sign-up flow
+
+ Step 2: Tell the tool what you want
+ - Explain the main input in simple, non-technical terms
+ - Provide a real example you used (from README)
+ - "For example, I entered '[YOUR EXAMPLE]' and here's why..."
+ - Explain what the Actor will do with this information
+ - Different approaches if Actor has multiple input options
+ - Keep it conversational: "Think of it like telling a smart assistant..."
+ - Screenshot description: Input form with your example filled in
+ - Personal tip: What worked best for you
+
+ Step 3: Fine-tune your settings (optional)
+ - "Here's where you can get more specific..."
+ - Explain optional settings in plain language
+ - When and why you might use them
+ - Your personal configuration and why
+ - "Honestly, the defaults work great for most people"
+ - Screenshot description: Advanced settings (if applicable)
+
+ Step 4: Add extra features (if you want)
+ - Explain any enrichment features from README in simple terms
+ - What additional information they provide
+ - Real-world example of how this helps
+ - "I added [feature] because..."
+ - When it's worth the extra cost (if applicable)
+
+ Step 5: Hit the Start button
+ - "This is the exciting part..."
+ - What happens when you click Start
+ - How long to expect (be specific)
+ - You can close your browser and come back
+ - What's happening behind the scenes (simple explanation)
+ - Personal note: "I grabbed a coffee while it worked its magic"
+ - Screenshot description: Run status page
+
+ Step 6: Check out your results
+ - "Once it's done, here's how to see your data..."
+ - Navigate to Results or Storage tab
+ - What the data looks like
+ - "I was amazed at how much information I got"
+ - Explain what the key information means
+ - Personal reaction to first seeing results
+ - Screenshot description: Results page with data preview
+
+ Step 7: Download and use your data
+ - Different formats available (CSV, Excel, JSON)
+ - Which format to choose and why
+ - "I downloaded mine as Excel because..."
+ - How to select just what you need
+ - What you can do with this data now
+ - Screenshot description: Export options
+
+ Each step should:
+ - Feel conversational and supportive
+ - Include your personal experience or tip
+ - Anticipate questions or concerns
+ - Be encouraging: "You've got this!"
+ - Use analogies to explain technical concepts
+
+6. "The results that surprised me" (200-250 words):
+ - What you actually got (specific examples)
+ - Time saved compared to manual work
+ - Quality or completeness of data
+ - Unexpected benefits you discovered
+ - How you used the data
+ - Real impact on your work/project
+ - Specific metrics: "It would have taken me 8 hours manually"
+
+7. "Tips I learned along the way" (150-200 words):
+ - 3-5 practical tips from your experience
+ - Mistakes you made so readers can avoid them
+ - How to get even better results
+ - Creative uses you discovered
+ - Time-saving shortcuts
+
+8. "What I built with this data" (100-150 words):
+ - How you actually used the results
+ - The outcome or project you created
+ - Why it mattered for your goal
+ - Inspiration for readers' use cases
+
+9. Conclusion (100-150 words):
+ - Recap the transformation (before/after)
+ - Encourage readers to try it themselves
+ - It's easier than they think
+ - What they could accomplish
+ - Clear call-to-action
+ - Invitation to share their results
+
+Writing guidelines:
+- Write in first person - tell YOUR story
+- Use "you" to directly address and encourage readers
+- Be warm, personable, and supportive
+- Share genuine reactions and emotions
+- Use simple, jargon-free language
+- When technical terms are necessary, explain them simply
+- Short paragraphs (2-3 sentences) for mobile reading
+- Use subheadings liberally for scannability
+- Include transitional phrases
+- Write like you're helping a friend
+- Show enthusiasm without being salesy
+
+Storytelling elements:
+- Include your personal "why"
+- Share the before/after transformation
+- Use specific details and examples
+- Create emotional connection
+- Show vulnerability (challenges you faced)
+- Celebrate the win at the end
+- Make readers feel "I can do this too"
+
+Accessibility:
+- Assume zero technical background
+- Explain every acronym or technical term
+- Use analogies: "It's like having a research assistant"
+- Break down complex steps into micro-steps
+- Anticipate anxiety: "Don't worry if you've never..."
+- Be reassuring throughout
+- Emphasize simplicity and ease
+
+Visual guidance:
+- Suggest 5-7 screenshots with detailed descriptions
+- Describe what readers should look for in each image
+- Include arrows or highlights (in description)
+- Show the complete visual journey
+- Before/after comparisons if possible
+
+Actor-specific details:
+- Use actual field names but explain them simply
+- Reference features from README in accessible language
+- Include your real configuration as an example
+- Show real output/results (anonymized if needed)
+- Mention pricing honestly and simply
+- Link to Actor naturally in the text
+
+SEO optimization:
+- Use "how to [achieve outcome]" or "how I [achieved outcome]" 5-7 times
+- Include related terms: "step by step," "tutorial," "guide," "easy way"
+- Use Actor name 5-8 times naturally
+- Include outcome keywords: "automate," "extract data," "save time"
+- Front-load keywords in title and opening paragraphs
+
+Medium-specific elements:
+- Suggest 5 strategic tags (e.g., "productivity," "automation," "tutorial," "data," "entrepreneurship")
+- Write compelling subtitle (under 140 characters) for under the title
+- Create hook opening sentence that grabs attention
+- Use bold text sparingly for key takeaways or important points
+- Suggest 2-3 Medium publications to submit to (Better Programming, The Startup, etc.)
+- Add ending note: "👏 If this helped you, please clap and follow for more tutorials!"
+- Include brief author bio at end (2-3 sentences, personal and relatable)
+
+Engagement elements:
+- Ask rhetorical questions to maintain engagement
+- Use "Pro tip:" or "Note:" callouts
+- Add personality and light humor where natural
+- Share honest reactions: "I couldn't believe how fast..."
+- Encourage readers: "You're doing great!"
+- End with inspiring call-to-action
+
+Please generate the complete tutorial now with engaging narrative structure, clear visual steps, and personal voice that makes Medium readers feel confident they can achieve the same results.`;
diff --git a/src/utils/quora-answer-prompt.js b/src/utils/quora-answer-prompt.js
new file mode 100644
index 000000000..6b091b9b5
--- /dev/null
+++ b/src/utils/quora-answer-prompt.js
@@ -0,0 +1,19 @@
+export const QUORA_ANSWER_PROMPT = `Create a Quora answer that mentions my Actor naturally.
+
+Question: [PASTE QUORA QUESTION]
+
+My Actor:
+- Name: [YOUR ACTOR NAME]
+- How it helps: [RELEVANT SOLUTION]
+
+Create an answer that:
+- Opens with a direct answer to the question
+- Provides context and background
+- Offers 2-3 different approaches or solutions
+- Mentions my Actor as one option with brief explanation
+- Includes personal experience or insights
+- Is 300-500 words
+- Uses subheadings for readability
+- Ends with a helpful summary
+
+Tone: Expert but approachable, helpful not salesy`;
diff --git a/src/utils/reddit-comment-prompt.js b/src/utils/reddit-comment-prompt.js
new file mode 100644
index 000000000..1b9bd2ba4
--- /dev/null
+++ b/src/utils/reddit-comment-prompt.js
@@ -0,0 +1,17 @@
+export const REDDIT_COMMENT_PROMPT = `Help me craft authentic Reddit comments to promote my Actor.
+
+Context:
+- Actor name: [YOUR ACTOR NAME]
+- What it does: [DESCRIPTION]
+- Thread topic: [REDDIT THREAD TITLE/TOPIC]
+
+Create 2-3 comment variations that:
+- Start by genuinely addressing the thread question/topic
+- Naturally mention my Actor as a solution
+- Don't sound promotional or salesy
+- Add real value to the conversation
+- Are 50-150 words each
+- Use casual Reddit tone (not corporate)
+- Include a brief personal experience or insight
+
+Each comment should feel like it's from a developer who happens to have built something relevant, not from someone trying to sell.`;
diff --git a/src/utils/twitter-post-prompt.js b/src/utils/twitter-post-prompt.js
new file mode 100644
index 000000000..8ecd913ff
--- /dev/null
+++ b/src/utils/twitter-post-prompt.js
@@ -0,0 +1,25 @@
+export const TWITTER_POST_PROMPT = `Create 5 engaging tweets to promote my Apify Actor with different angles.
+
+Actor details:
+- Name: [YOUR ACTOR NAME]
+- Main benefit: [KEY VALUE PROPOSITION]
+- Use case: [SPECIFIC PROBLEM IT SOLVES]
+
+For each tweet, create:
+- An opening hook (problem or surprising fact)
+- A brief explanation of the solution
+- Call-to-action
+- Relevant hashtags (3-5)
+
+Variations should include:
+1. A "Before vs After" style tweet
+2. A problem/solution tweet
+3. A "just launched" announcement
+4. A technical feature highlight
+5. A use case story
+
+Keep each tweet:
+- Under 280 characters
+- Conversational tone
+- Include emoji where natural
+- Not overly promotional`;