Product Marketing AI Actor

An AI-powered Apify Actor that automatically generates marketing content based on product updates from GitHub repositories. It analyzes commits, pull requests, and releases to create blog posts, help desk articles, landing page content, and more using Claude AI.

Features

• 🔍 GitHub Repository Analysis: Automatically scans your product repositories for recent changes
• 🤖 AI-Powered Content Generation: Uses Claude AI to generate high-quality marketing content
• 📝 Multiple Content Types: Supports blog posts, help desk articles, landing pages, social media posts, and release notes
• 💾 Flexible Storage: Store generated content in Apify Dataset or Key-Value Store
• 🔄 Customizable Time Period: Analyze changes from the last 7, 30, or 365 days
• 🏷️ Smart Categorization: Automatically categorizes changes into features, improvements, bug fixes, and breaking changes

Use Cases

• Product Marketing Teams: Automatically generate blog posts when new features are released
• Documentation Teams: Create help desk articles for new functionality
• Developer Relations: Generate release notes and social media announcements
• Content Marketing: Keep your landing pages updated with latest product improvements
• Customer Success: Provide timely documentation for product changes

Input Configuration

Required Fields

• Company URL (companyUrl): Your company's website URL for brand context

  • Example: https://mycompany.com

• GitHub Token (githubToken): Personal access token for GitHub API access

  • Required scopes: repo (for private repos) or public_repo (for public repos)
  • Create a token here

• Product Repository (productRepository): Main product repository

  • Format: owner/repo
  • Example: mycompany/product

• Anthropic API Key (anthropicApiKey): API key for Claude AI (Optional)

  • Get your API key from Anthropic Console
  • If not provided, will fall back to claudeCodeOAuthToken or ANTHROPIC_API_KEY environment variable

Optional Fields

• Claude Code OAuth Token (claudeCodeOAuthToken): Legacy API key field (Optional)

  • Deprecated: Use anthropicApiKey instead
  • Still supported for backward compatibility

• Landing Page Repository (landingPageRepository): Repository for landing page code

  • Format: owner/repo
  • Example: mycompany/landing-page

• Documentation Repository (documentationRepository): Repository for documentation

  • Format: owner/repo
  • Example: mycompany/docs

• Content Types (contentTypes): Array of content types to generate

  • Options: blog_post, help_desk_article, landing_page, social_media, release_notes
  • Default: ["blog_post", "help_desk_article"]

• Days to Analyze (daysToAnalyze): How far back to look for changes

  • Range: 1-365 days
  • Default: 30 days

• Storage Type (storageType): Where to store generated content

  • Options: dataset, key_value_store, both
  • Default: dataset

How It Works

1. Repository Analysis

   • Connects to specified GitHub repositories using your token
   • Fetches commits, merged pull requests, and releases from the specified time period
   • Analyzes commit messages and PR labels to understand the nature of changes

2. Change Categorization

   • Automatically categorizes changes into:
     • Features: New functionality (labels: feature, enhancement, or commit prefix feat:)
     • Improvements: Enhancements to existing features (labels: improvement, refactor)
     • Bug Fixes: Fixed issues (labels: bug, fix, or commit prefix fix:)
     • Breaking Changes: Changes that may require migration (labels: breaking change)

3. Content Generation

   • Uses Claude AI to generate marketing content based on categorized changes
   • Each content type has specialized prompts optimized for its purpose
   • Generates engaging, professional content tailored to your brand

4. Storage

   • Saves generated content to Apify Dataset and/or Key-Value Store
   • Includes metadata: generation timestamp, source changes, content type
   • Creates a summary of all generated content for easy retrieval

Output Format

Dataset Output

Each item in the dataset contains:

{
  "type": "blog_post",
  "title": "Introducing New Features in Product v2.0",
  "content": "Full markdown content...",
  "metadata": {
    "generatedAt": "2024-01-15T10:30:00.000Z",
    "basedOnChanges": 15,
    "contentType": "blog_post"
  },
  "productUpdate": {
    "features": ["Feature 1", "Feature 2"],
    "improvements": ["Improvement 1"],
    "bugFixes": ["Fix 1"],
    "breakingChanges": []
  },
  "repositories": ["owner/product", "owner/docs"],
  "analyzedPeriod": {
    "days": 30,
    "endDate": "2024-01-15T10:30:00.000Z"
  }
}

Key-Value Store Output

When using Key-Value Store, each content piece is stored with a unique key:

• Key format: {contentType}_{timestamp}_{randomId}
• Example: blog_post_1705315800000_abc123xyz

A summary is also stored with key latest_summary:

{
  "generatedAt": "2024-01-15T10:30:00.000Z",
  "totalContents": 2,
  "contentTypes": ["blog_post", "help_desk_article"],
  "repositories": ["owner/product"],
  "changes": {
    "features": 5,
    "improvements": 3,
    "bugFixes": 7,
    "breakingChanges": 0
  }
}

Content Types Explained

Blog Post

• Length: 800-1200 words
• Tone: Professional yet conversational
• Structure: Introduction, feature sections, conclusion with CTA
• Best for: Announcing major updates, new features, product milestones

Help Desk Article

• Length: 500-800 words
• Tone: Clear and instructional
• Structure: Step-by-step instructions, examples, FAQs
• Best for: Explaining how to use new features, troubleshooting guides

Landing Page

• Length: Concise and scannable
• Tone: Persuasive and benefit-focused
• Structure: Headline, value proposition, feature bullets, CTAs
• Best for: Product pages, feature announcements, campaign landing pages

Social Media

• Length: 3 posts (short, medium, long)
• Tone: Engaging and shareable
• Structure: Attention-grabbing copy with hashtags and emojis
• Best for: Twitter, LinkedIn, Facebook announcements

Release Notes

• Length: Varies by changes
• Tone: Technical and precise
• Structure: Categorized list of changes with details
• Best for: Developer documentation, changelog, version announcements

Local Development

Prerequisites

• Bun installed: curl -fsSL https://bun.sh/install | bash
• Apify CLI: curl -fsSL https://apify.com/install-cli.sh | bash
• Node.js 20+
• Git

Setup

# Clone or create the project
mkdir product-marketing-actor
cd product-marketing-actor

# Install dependencies
bun install

# Set up environment variables for local testing
export GITHUB_TOKEN="your_github_token"
export ANTHROPIC_API_KEY="your_anthropic_api_key"
export COMPANY_URL="https://yourcompany.com"
export PRODUCT_REPO="owner/repo"

Run Locally

# Development mode
bun run dev

# Build
bun run build

# Run built version
bun run start

Test with Apify CLI

# Login to Apify
apify login

# Run locally with Apify storage
apify run

Deployment

Deploy to Apify Platform

# Build and push to Apify
apify push

Configure on Apify Platform

1. Go to Apify Console
2. Navigate to your Actor
3. Click on "Input" tab
4. Fill in the required fields:
   • Company URL
   • GitHub Token (use secret input)
   • Product Repository
   • Claude Code OAuth Token (use secret input)
5. Configure optional fields as needed
6. Click "Start" to run the Actor

Schedule Runs

To automatically generate content on a regular basis:

1. Go to your Actor in Apify Console
2. Click "Schedules" tab
3. Create a new schedule (e.g., weekly, monthly)
4. Configure the input parameters
5. Save the schedule

Example schedules:

• Weekly: Generate blog posts every Monday for last week's changes
• Monthly: Create comprehensive monthly update articles
• On Release: Trigger manually after major releases

Environment Variables

For production deployment, set these as secret environment variables in Apify:

• GITHUB_TOKEN: GitHub personal access token
• ANTHROPIC_API_KEY: Claude AI API key

These can be accessed in the Actor but won't be exposed in logs.

Best Practices

GitHub Token Permissions

For private repositories:

• Required scope: repo (full control of private repositories)

For public repositories only:

• Required scope: public_repo (access public repositories)

Content Quality Tips

1. Provide Context: Make sure your commit messages and PR descriptions are clear
2. Use Labels: Tag PRs with appropriate labels (feature, bug, breaking change)
3. Write Good Commits: Use conventional commit format (feat:, fix:, refactor:)
4. Regular Runs: Run the Actor regularly to capture incremental changes
5. Review Generated Content: Always review AI-generated content before publishing

Rate Limiting

• GitHub API: 5,000 requests/hour (authenticated)
• Claude AI: Depends on your plan
• Actor adds 1-second delays between content generation to avoid rate limits

Troubleshooting

Common Issues

"No changes found in any repository"

• Check that your repositories have recent commits/PRs/releases
• Verify the daysToAnalyze parameter covers the period you want
• Ensure your GitHub token has access to the repositories

"Failed to analyze repository"

• Verify repository name format is owner/repo
• Check GitHub token permissions
• Ensure repositories exist and are accessible

"Error generating content"

• Verify Claude API key is valid
• Check your API usage limits
• Ensure there are enough changes to generate content from

"Authentication failed"

• Regenerate GitHub token with correct permissions
• Verify Claude API key in Anthropic Console
• Check tokens are not expired

API Integration

Using with Apify API

// Run the Actor via API
const run = await apifyClient.actor('YOUR_ACTOR_ID').call({
  companyUrl: 'https://mycompany.com',
  githubToken: 'ghp_xxxxx',
  productRepository: 'mycompany/product',
  claudeCodeOAuthToken: 'sk-ant-xxxxx',
  contentTypes: ['blog_post', 'help_desk_article'],
  daysToAnalyze: 30,
  storageType: 'dataset'
});

// Get results
const dataset = await apifyClient.dataset(run.defaultDatasetId).listItems();
console.log(dataset.items);

Webhook Integration

Set up webhooks to trigger the Actor when:

• New releases are published on GitHub
• Pull requests are merged
• Scheduled times (daily, weekly, monthly)

Cost Estimation

Apify Platform

• Free tier: 3 hours of compute time/month
• Typical run: 2-5 minutes depending on changes and content types
• Estimated cost: $0.02-0.10 per run on paid plans

Claude AI API

• Cost depends on content length and complexity
• Typical usage: 500-2000 tokens per content piece
• Estimated cost: $0.01-0.05 per content piece

GitHub API

• Free for authenticated requests (5,000/hour)
• No additional cost

Support

• Apify Documentation: https://docs.apify.com/
• Claude AI Docs: https://docs.anthropic.com/
• GitHub API Docs: https://docs.github.com/en/rest

License

ISC

Contributing

Contributions welcome! Please feel free to submit issues or pull requests.

---

Built with:

• Apify SDK
• Claude AI
• GitHub API
• Bun
• TypeScript