Create api.py

api.py

@@ -0,0 +1,697 @@
+import json
+from typing import Dict, Any, Optional
+import requests
+import os
+import time
+# import gspread  # TODO: Install with pip install gspread
+# from slack_sdk import WebClient  # TODO: Install with pip install slack-sdk
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+
+# FastAPI application for converted n8n workflow
+app = FastAPI(
+    title="n8n2py Converted Workflow",
+    description="Converted n8n workflow running as FastAPI service",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# Add CORS middleware for cross-origin requests
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure this for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+def run_workflow(data: Dict[str, Any]) -> Dict[str, Any]:
+    '''
+    Execute the converted n8n workflow
+    Generated from n8n workflow conversion using n8n2py
+    
+    Args:
+        data: Input data for the workflow
+        
+    Returns:
+        Dict containing execution results
+    '''
+    print("🚀 Starting workflow execution with data:", data)
+    
+    try:
+
+        # TODO: Unknown node type: n8n-nodes-base.stickyNote
+        # Node: Sticky Note
+        # This node type is not recognized by n8n2py
+        # Parameters: {
+        "content": "# Research Daily News and Write Script",
+        "height": 2100,
+        "width": 940,
+        "color": 2
+}
+        # 
+        # To implement this node:
+        # 1. Research the node's functionality in n8n documentation
+        # 2. Find appropriate Python libraries for the same functionality
+        # 3. Add implementation to nodeHandlers.ts
+        # 4. Test the conversion
+        
+        print(f"⚠️ Skipping unknown node: Sticky Note ({node.type})")
+
+
+        # TODO: Unknown node type: n8n-nodes-base.stickyNote
+        # Node: Sticky Note1
+        # This node type is not recognized by n8n2py
+        # Parameters: {
+        "content": "# Create AI Avatar Video\n\n- Heygen API plan (paid) is required; the free plan is insufficient.\n- if you have a long script, you may need to increase the WAIT time.\n- you can use Elevenlabs voice by integrating Elevenlabs from within Heygen app.",
+        "height": 2100,
+        "width": 800,
+        "color": 3
+}
+        # 
+        # To implement this node:
+        # 1. Research the node's functionality in n8n documentation
+        # 2. Find appropriate Python libraries for the same functionality
+        # 3. Add implementation to nodeHandlers.ts
+        # 4. Test the conversion
+        
+        print(f"⚠️ Skipping unknown node: Sticky Note1 ({node.type})")
+
+
+        # TODO: Unknown node type: n8n-nodes-base.stickyNote
+        # Node: Sticky Note2
+        # This node type is not recognized by n8n2py
+        # Parameters: {
+        "content": "# Publish to Social Media\n\n- Sign up for Blotato: https://www.blotato.com\n- Blotato's API currently doesn't support uploading videos to Bluesky or Pinterest. \n- This feature will be released in the future, so I've deactivated the nodes for now.",
+        "height": 2100,
+        "width": 1120,
+        "color": 4
+}
+        # 
+        # To implement this node:
+        # 1. Research the node's functionality in n8n documentation
+        # 2. Find appropriate Python libraries for the same functionality
+        # 3. Add implementation to nodeHandlers.ts
+        # 4. Test the conversion
+        
+        print(f"⚠️ Skipping unknown node: Sticky Note2 ({node.type})")
+
+
+        # HTTP Request: [Instagram] Publish via Blotato
+        headers = {"Content-Type": "application/json"}
+
+        instagram_publish_via_blotato_response = requests.post(
+            url="https://backend.blotato.com/v2/posts",
+            headers=headers
+        )
+
+        # Handle response
+        if instagram_publish_via_blotato_response.status_code == 200:
+            instagram_publish_via_blotato_data = instagram_publish_via_blotato_response.json()
+            print(f"✅ [Instagram] Publish via Blotato successful: {instagram_publish_via_blotato_response.status_code}")
+        else:
+            print(f"❌ [Instagram] Publish via Blotato failed: {instagram_publish_via_blotato_response.status_code}")
+            instagram_publish_via_blotato_data = None
+
+
+        # HTTP Request: [Youtube] Publish via Blotato
+        headers = {"Content-Type": "application/json"}
+
+        youtube_publish_via_blotato_response = requests.post(
+            url="https://backend.blotato.com/v2/posts",
+            headers=headers
+        )
+
+        # Handle response
+        if youtube_publish_via_blotato_response.status_code == 200:
+            youtube_publish_via_blotato_data = youtube_publish_via_blotato_response.json()
+            print(f"✅ [Youtube] Publish via Blotato successful: {youtube_publish_via_blotato_response.status_code}")
+        else:
+            print(f"❌ [Youtube] Publish via Blotato failed: {youtube_publish_via_blotato_response.status_code}")
+            youtube_publish_via_blotato_data = None
+
+
+        # HTTP Request: [Facebook] Publish via Blotato
+        headers = {"Content-Type": "application/json"}
+
+        facebook_publish_via_blotato_response = requests.post(
+            url="https://backend.blotato.com/v2/posts",
+            headers=headers
+        )
+
+        # Handle response
+        if facebook_publish_via_blotato_response.status_code == 200:
+            facebook_publish_via_blotato_data = facebook_publish_via_blotato_response.json()
+            print(f"✅ [Facebook] Publish via Blotato successful: {facebook_publish_via_blotato_response.status_code}")
+        else:
+            print(f"❌ [Facebook] Publish via Blotato failed: {facebook_publish_via_blotato_response.status_code}")
+            facebook_publish_via_blotato_data = None
+
+
+        # HTTP Request: [Threads] Publish via Blotato
+        headers = {"Content-Type": "application/json"}
+
+        threads_publish_via_blotato_response = requests.post(
+            url="https://backend.blotato.com/v2/posts",
+            headers=headers
+        )
+
+        # Handle response
+        if threads_publish_via_blotato_response.status_code == 200:
+            threads_publish_via_blotato_data = threads_publish_via_blotato_response.json()
+            print(f"✅ [Threads] Publish via Blotato successful: {threads_publish_via_blotato_response.status_code}")
+        else:
+            print(f"❌ [Threads] Publish via Blotato failed: {threads_publish_via_blotato_response.status_code}")
+            threads_publish_via_blotato_data = None
+
+
+        # TODO: Unknown node type: @n8n/n8n-nodes-langchain.openAi
+        # Node: Write Long Caption
+        # This node type is not recognized by n8n2py
+        # Parameters: {
+        "modelId": {
+                "__rl": true,
+                "value": "gpt-4o",
+                "mode": "list",
+                "cachedResultName": "GPT-4O"
+        },
+        "messages": {
+                "values": [
+                        {
+                                "content": "=# EXAMPLE\n\n<example>\nMany people have recently asked me about ask engine optimization, which is all about optimizing your website and existing content, so it can be pulled into ChatGPT and other generative AI tools. Consider that generative AI tools tend to be more conversational in nature and have a Q&A type format, so search engines will want to pull in snippets that concisely answer a user’s question.- what is ask engine optimization in the age of AI?- How does traditional SEO compare to ask engine optimization today?- top tips and tricks to get started with ask engine optimization?\n\n#ai #askengineoptimization #chatgpts #seo #aitools #digitalmarketing\n</example>\n\n# CONTEXT\n\nInfer the topic from the sources provided.\n\n# WRITING STYLE\n\nHere’s how you always write:\n\n<writing_style>\n\n- Your writing style is spartan and informative.\n- Use clear, simple language.\n- Employ short, impactful sentences.\n- Use active voice; avoid passive voice.\n- Focus on practical, actionable insights.\n- Incorporate data or statistics to support claims when possible.\n- Use \"\"\"\"\"\"\"\"you\"\"\"\"\"\"\"\" and \"\"\"\"\"\"\"\"your\"\"\"\"\"\"\"\" to directly address the reader.\n- Avoid metaphors and clichés.\n- Avoid generalizations.\n- Do not include common setup language in any sentence, including: in conclusion, in closing, etc.\n- Do not output warnings or notes—just the output requested.\n- Do not use hashtags.\n- Do not use semicolons.\n- Do not use emojis.\n- Do not use asterisks.\n- Do not use adjectives and adverbs.\n- Do NOT use these words:\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"can, may, just, that, very, really, literally, actually, certainly, probably, basically, could, maybe, delve, embark, enlightening, esteemed, shed light, craft, crafting, imagine, realm, game-changer, unlock, discover, skyrocket, abyss, you're not alone, in a world where, revolutionize, disruptive, utilize, utilizing, dive deep, tapestry, illuminate, unveil, pivotal, enrich, intricate, elucidate, hence, furthermore, realm, however, harness, exciting, groundbreaking, cutting-edge, remarkable, it. remains to be seen, glimpse into, navigating, landscape, stark, testament, in summary, in conclusion, moreover, boost, bustling, opened up, powerful, inquiries, ever-evolving\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n</writing_style>\n\n# PLANNING\n\nYour goal is to write a 50-word video caption based on the provided source.\n\n1. Analyze the provided sources thoroughly.\n2. Study the <example> post carefully. You will be asked to replicate their:\n    - Overall structure.\n    - Tone and voice.\n    - Formatting (including line breaks and spacing).\n    - Length (aim for a similarly detailed post).\n    - Absence of emojis.\n    - Use of hashtags.\n    - Emotional resonance.\n\n# OUTPUT\nFollow the GUIDELINES below to write the post. Use your analysis from step 1 and step 2. Use the provided sources as the foundation for your post, expanding on it significantly while maintaining the style and structure of the examples provided from step 2. You MUST use information from the provided sources. Make sure you adhere to your <writing_style>.\n\n<guidelines>\nThe description should be structured as follows:\n1. Start with 1 paragraph summarizing the source\n2. Newline, followed by 3 bullet points of questions that a viewer might ask on a search engine about the source\n3. Newline, followed by these hashtags: #ai #artificialintelligence #ainews #sabrinaramonov #aiavatar\n</guidelines>\n\nTake a deep breath and take it step-by-step!\n\n# INPUT\nUse the following information sources:\n<sources>\n{{ $json.output }}\n</sources>"
+                        }
+                ]
+        },
+        "options": {}
+}
+        # 
+        # To implement this node:
+        # 1. Research the node's functionality in n8n documentation
+        # 2. Find appropriate Python libraries for the same functionality
+        # 3. Add implementation to nodeHandlers.ts
+        # 4. Test the conversion
+        
+        print(f"⚠️ Skipping unknown node: Write Long Caption ({node.type})")
+
+
+        # TODO: Unknown node type: n8n-nodes-base.scheduleTrigger
+        # Node: Schedule Trigger
+        # This node type is not recognized by n8n2py
+        # Parameters: {
+        "rule": {
+                "interval": [
+                        {
+                                "triggerAtHour": 10
+                        }
+                ]
+        }
+}
+        # 
+        # To implement this node:
+        # 1. Research the node's functionality in n8n documentation
+        # 2. Find appropriate Python libraries for the same functionality
+        # 3. Add implementation to nodeHandlers.ts
+        # 4. Test the conversion
+        
+        print(f"⚠️ Skipping unknown node: Schedule Trigger ({node.type})")
+
+
+        # TODO: Unknown node type: @n8n/n8n-nodes-langchain.agent
+        # Node: AI Agent
+        # This node type is not recognized by n8n2py
+        # Parameters: {
+        "promptType": "define",
+        "text": "# INSTRUCTIONS\n\nPerform the following tasks, in order:\n\n1. Fetch the top 10 stories from Hacker News from the past 24 hours related to AI or LLMs. \n\n2. Select the top story that is most likely to go viral on social media. \n\n3. Fetch the article and Hacker News comments.\n\n4. Create a 30-second monologue script for an AI avatar video, following these guidelines:\n   - The script should be approximately 30 seconds when spoken aloud.\n   - Include lots of details and statistics from the article.\n   - Use 6th grade reading level.\n   - Balanced viewpoint.\n   - Script should be in single paragraph\n\n5. Update the script's first 2 sentences to use sensational viral hooks that grab the viewer's attention and spark curiosity. The 3rd sentence should start diving into the article's details.\n\n6. Replace the last sentence with: \"Hit follow to stay ahead in AI!\"\n\n# OUTPUT FORMAT\n\nONLY output the exact video script. Do not output anything else. NEVER include intermediate thoughts, notes, or formatting.\nR",
+        "options": {
+                "returnIntermediateSteps": true
+        }
+}
+        # 
+        # To implement this node:
+        # 1. Research the node's functionality in n8n documentation
+        # 2. Find appropriate Python libraries for the same functionality
+        # 3. Add implementation to nodeHandlers.ts
+        # 4. Test the conversion
+        
+        print(f"⚠️ Skipping unknown node: AI Agent ({node.type})")
+
+
+        # Set Variables: Setup Heygen
+        # No variables to set
+
+
+        # HTTP Request: Create Avatar Video
+        base_url = os.getenv("HTTP_BASE_URL", "https://api.heygen.com/v2/video/generate")
+        headers = {"Content-Type": "application/json"}
+
+        create_avatar_video_response = requests.post(
+            url=base_url,
+            headers=headers
+        )
+
+        # Handle response
+        if create_avatar_video_response.status_code == 200:
+            create_avatar_video_data = create_avatar_video_response.json()
+            print(f"✅ Create Avatar Video successful: {create_avatar_video_response.status_code}")
+        else:
+            print(f"❌ Create Avatar Video failed: {create_avatar_video_response.status_code}")
+            create_avatar_video_data = None
+
+
+        # TODO: Unknown node type: n8n-nodes-base.wait
+        # Node: Wait
+        # This node type is not recognized by n8n2py
+        # Parameters: {
+        "amount": 8,
+        "unit": "minutes"
+}
+        # 
+        # To implement this node:
+        # 1. Research the node's functionality in n8n documentation
+        # 2. Find appropriate Python libraries for the same functionality
+        # 3. Add implementation to nodeHandlers.ts
+        # 4. Test the conversion
+        
+        print(f"⚠️ Skipping unknown node: Wait ({node.type})")
+
+
+        # HTTP Request: Get Avatar Video
+        base_url = os.getenv("HTTP_BASE_URL", "https://api.heygen.com/v1/video_status.get")
+        headers = {"Content-Type": "application/json"}
+
+        get_avatar_video_response = requests.get(
+            url=base_url,
+            headers=headers
+        )
+
+        # Handle response
+        if get_avatar_video_response.status_code == 200:
+            get_avatar_video_data = get_avatar_video_response.json()
+            print(f"✅ Get Avatar Video successful: {get_avatar_video_response.status_code}")
+        else:
+            print(f"❌ Get Avatar Video failed: {get_avatar_video_response.status_code}")
+            get_avatar_video_data = None
+
+
+        # Set Variables: Prepare for Publish
+        # No variables to set
+
+
+        # HTTP Request: Upload to Blotato
+        headers = {"Content-Type": "application/json"}
+
+        upload_to_blotato_response = requests.post(
+            url="https://backend.blotato.com/v2/media",
+            headers=headers
+        )
+
+        # Handle response
+        if upload_to_blotato_response.status_code == 200:
+            upload_to_blotato_data = upload_to_blotato_response.json()
+            print(f"✅ Upload to Blotato successful: {upload_to_blotato_response.status_code}")
+        else:
+            print(f"❌ Upload to Blotato failed: {upload_to_blotato_response.status_code}")
+            upload_to_blotato_data = None
+
+
+        # HTTP Request: [Linkedin] Publish via Blotato
+        headers = {"Content-Type": "application/json"}
+
+        linkedin_publish_via_blotato_response = requests.post(
+            url="https://backend.blotato.com/v2/posts",
+            headers=headers
+        )
+
+        # Handle response
+        if linkedin_publish_via_blotato_response.status_code == 200:
+            linkedin_publish_via_blotato_data = linkedin_publish_via_blotato_response.json()
+            print(f"✅ [Linkedin] Publish via Blotato successful: {linkedin_publish_via_blotato_response.status_code}")
+        else:
+            print(f"❌ [Linkedin] Publish via Blotato failed: {linkedin_publish_via_blotato_response.status_code}")
+            linkedin_publish_via_blotato_data = None
+
+
+        # HTTP Request: [Twitter] Publish via Blotato
+        headers = {"Content-Type": "application/json"}
+
+        twitter_publish_via_blotato_response = requests.post(
+            url="https://backend.blotato.com/v2/posts",
+            headers=headers
+        )
+
+        # Handle response
+        if twitter_publish_via_blotato_response.status_code == 200:
+            twitter_publish_via_blotato_data = twitter_publish_via_blotato_response.json()
+            print(f"✅ [Twitter] Publish via Blotato successful: {twitter_publish_via_blotato_response.status_code}")
+        else:
+            print(f"❌ [Twitter] Publish via Blotato failed: {twitter_publish_via_blotato_response.status_code}")
+            twitter_publish_via_blotato_data = None
+
+
+        # TODO: Unknown node type: @n8n/n8n-nodes-langchain.openAi
+        # Node: Write Short Caption
+        # This node type is not recognized by n8n2py
+        # Parameters: {
+        "modelId": {
+                "__rl": true,
+                "value": "gpt-4o",
+                "mode": "list",
+                "cachedResultName": "GPT-4O"
+        },
+        "messages": {
+                "values": [
+                        {
+                                "content": "=Write a spartan 2-sentence caption summarizing the video content, use 6th grade language, balanced neutral perspective, no emojis:\n\n<content>\n{{ $json.message.content }}\n</content>"
+                        }
+                ]
+        },
+        "options": {}
+}
+        # 
+        # To implement this node:
+        # 1. Research the node's functionality in n8n documentation
+        # 2. Find appropriate Python libraries for the same functionality
+        # 3. Add implementation to nodeHandlers.ts
+        # 4. Test the conversion
+        
+        print(f"⚠️ Skipping unknown node: Write Short Caption ({node.type})")
+
+
+        # TODO: Unknown node type: n8n-nodes-base.stickyNote
+        # Node: Sticky Note3
+        # This node type is not recognized by n8n2py
+        # Parameters: {
+        "content": "## Make sure you fill out \"Setup Heygen\"",
+        "height": 180,
+        "width": 150,
+        "color": 6
+}
+        # 
+        # To implement this node:
+        # 1. Research the node's functionality in n8n documentation
+        # 2. Find appropriate Python libraries for the same functionality
+        # 3. Add implementation to nodeHandlers.ts
+        # 4. Test the conversion
+        
+        print(f"⚠️ Skipping unknown node: Sticky Note3 ({node.type})")
+
+
+        # TODO: Unknown node type: n8n-nodes-base.stickyNote
+        # Node: Sticky Note4
+        # This node type is not recognized by n8n2py
+        # Parameters: {
+        "content": "## Make sure you fill out \"Prepare for Publish\"",
+        "height": 180,
+        "width": 160,
+        "color": 6
+}
+        # 
+        # To implement this node:
+        # 1. Research the node's functionality in n8n documentation
+        # 2. Find appropriate Python libraries for the same functionality
+        # 3. Add implementation to nodeHandlers.ts
+        # 4. Test the conversion
+        
+        print(f"⚠️ Skipping unknown node: Sticky Note4 ({node.type})")
+
+
+        # TODO: Unknown node type: @n8n/n8n-nodes-langchain.lmChatOpenAi
+        # Node: Write Script
+        # This node type is not recognized by n8n2py
+        # Parameters: {
+        "model": {
+                "__rl": true,
+                "value": "gpt-4o-mini",
+                "mode": "list",
+                "cachedResultName": "gpt-4o-mini"
+        },
+        "options": {}
+}
+        # 
+        # To implement this node:
+        # 1. Research the node's functionality in n8n documentation
+        # 2. Find appropriate Python libraries for the same functionality
+        # 3. Add implementation to nodeHandlers.ts
+        # 4. Test the conversion
+        
+        print(f"⚠️ Skipping unknown node: Write Script ({node.type})")
+
+
+        # TODO: Unknown node type: n8n-nodes-base.hackerNewsTool
+        # Node: Fetch HN Front Page
+        # This node type is not recognized by n8n2py
+        # Parameters: {
+        "resource": "all",
+        "additionalFields": {
+                "keyword": "AI",
+                "tags": [
+                        "front_page"
+                ]
+        }
+}
+        # 
+        # To implement this node:
+        # 1. Research the node's functionality in n8n documentation
+        # 2. Find appropriate Python libraries for the same functionality
+        # 3. Add implementation to nodeHandlers.ts
+        # 4. Test the conversion
+        
+        print(f"⚠️ Skipping unknown node: Fetch HN Front Page ({node.type})")
+
+
+        # TODO: Unknown node type: n8n-nodes-base.hackerNewsTool
+        # Node: Fetch HN Article
+        # This node type is not recognized by n8n2py
+        # Parameters: {
+        "articleId": "={{ /*n8n-auto-generated-fromAI-override*/ $fromAI('Article_ID', ``, 'string') }}",
+        "additionalFields": {
+                "includeComments": true
+        }
+}
+        # 
+        # To implement this node:
+        # 1. Research the node's functionality in n8n documentation
+        # 2. Find appropriate Python libraries for the same functionality
+        # 3. Add implementation to nodeHandlers.ts
+        # 4. Test the conversion
+        
+        print(f"⚠️ Skipping unknown node: Fetch HN Article ({node.type})")
+
+
+        # HTTP Request: [Tiktok] Publish via Blotato
+        headers = {"Content-Type": "application/json"}
+
+        tiktok_publish_via_blotato_response = requests.post(
+            url="https://backend.blotato.com/v2/posts",
+            headers=headers
+        )
+
+        # Handle response
+        if tiktok_publish_via_blotato_response.status_code == 200:
+            tiktok_publish_via_blotato_data = tiktok_publish_via_blotato_response.json()
+            print(f"✅ [Tiktok] Publish via Blotato successful: {tiktok_publish_via_blotato_response.status_code}")
+        else:
+            print(f"❌ [Tiktok] Publish via Blotato failed: {tiktok_publish_via_blotato_response.status_code}")
+            tiktok_publish_via_blotato_data = None
+
+
+        # HTTP Request: [Bluesky] Publish via Blotato
+        headers = {"Content-Type": "application/json"}
+
+        bluesky_publish_via_blotato_response = requests.post(
+            url="https://backend.blotato.com/v2/posts",
+            headers=headers
+        )
+
+        # Handle response
+        if bluesky_publish_via_blotato_response.status_code == 200:
+            bluesky_publish_via_blotato_data = bluesky_publish_via_blotato_response.json()
+            print(f"✅ [Bluesky] Publish via Blotato successful: {bluesky_publish_via_blotato_response.status_code}")
+        else:
+            print(f"❌ [Bluesky] Publish via Blotato failed: {bluesky_publish_via_blotato_response.status_code}")
+            bluesky_publish_via_blotato_data = None
+
+
+        # TODO: Unknown node type: @n8n/n8n-nodes-langchain.openAi
+        # Node: OpenAI
+        # This node type is not recognized by n8n2py
+        # Parameters: {
+        "resource": "image",
+        "prompt": "={{ $('Prepare for Publish').item.json.final_text_long }}",
+        "options": {
+                "returnImageUrls": true
+        }
+}
+        # 
+        # To implement this node:
+        # 1. Research the node's functionality in n8n documentation
+        # 2. Find appropriate Python libraries for the same functionality
+        # 3. Add implementation to nodeHandlers.ts
+        # 4. Test the conversion
+        
+        print(f"⚠️ Skipping unknown node: OpenAI ({node.type})")
+
+
+        # HTTP Request: Upload to Blotato - Image
+        headers = {"Content-Type": "application/json"}
+
+        upload_to_blotato_image_response = requests.post(
+            url="https://backend.blotato.com/v2/media",
+            headers=headers
+        )
+
+        # Handle response
+        if upload_to_blotato_image_response.status_code == 200:
+            upload_to_blotato_image_data = upload_to_blotato_image_response.json()
+            print(f"✅ Upload to Blotato - Image successful: {upload_to_blotato_image_response.status_code}")
+        else:
+            print(f"❌ Upload to Blotato - Image failed: {upload_to_blotato_image_response.status_code}")
+            upload_to_blotato_image_data = None
+
+
+        # HTTP Request: [Pinterest] Publish via Blotato
+        headers = {"Content-Type": "application/json"}
+
+        pinterest_publish_via_blotato_response = requests.post(
+            url="https://backend.blotato.com/v2/posts",
+            headers=headers
+        )
+
+        # Handle response
+        if pinterest_publish_via_blotato_response.status_code == 200:
+            pinterest_publish_via_blotato_data = pinterest_publish_via_blotato_response.json()
+            print(f"✅ [Pinterest] Publish via Blotato successful: {pinterest_publish_via_blotato_response.status_code}")
+        else:
+            print(f"❌ [Pinterest] Publish via Blotato failed: {pinterest_publish_via_blotato_response.status_code}")
+            pinterest_publish_via_blotato_data = None
+
+        
+        # Return the workflow results
+        result = {
+            "status": "success",
+            "message": "Workflow executed successfully",
+            "data": data,
+            "timestamp": json.dumps({"executed_at": str(__import__('datetime').datetime.now())})
+        }
+        
+        print("✅ Workflow completed successfully!")
+        return result
+        
+    except Exception as e:
+        error_msg = f"Workflow execution failed: {str(e)}"
+        print(f"❌ {error_msg}")
+        import traceback
+        traceback.print_exc()
+        
+        return {
+            "status": "error",
+            "message": error_msg,
+            "error_type": type(e).__name__,
+            "data": data,
+            "timestamp": json.dumps({"executed_at": str(__import__('datetime').datetime.now())})
+        }
+
+@app.get("/")
+async def root():
+    '''Root endpoint with API information'''
+    return {
+        "message": "n8n2py converted workflow is running",
+        "status": "healthy",
+        "service": "n8n2py-workflow",
+        "endpoints": {
+            "POST /run": "Execute the workflow",
+            "GET /docs": "Interactive API documentation",
+            "GET /redoc": "Alternative API documentation",
+            "GET /health": "Health check endpoint"
+        },
+        "version": "1.0.0"
+    }
+
+@app.get("/health")
+async def health_check():
+    '''Health check endpoint for monitoring'''
+    return {
+        "status": "healthy",
+        "service": "n8n2py-workflow",
+        "timestamp": str(__import__('datetime').datetime.now())
+    }
+
+@app.post("/run")
+async def execute_workflow(request: Request):
+    '''
+    Execute the converted n8n workflow
+    
+    Send a POST request with JSON data to trigger the workflow execution.
+    The workflow will process the input data and return results.
+    
+    Example request:
+    ```json
+    {
+        "parameters": {
+            "key": "value",
+            "another_key": "another_value"
+        }
+    }
+    ```
+    '''
+    try:
+        # Parse request body
+        data = await request.json()
+    except Exception as e:
+        raise HTTPException(
+            status_code=400,
+            detail={
+                "error": "Invalid JSON in request body",
+                "message": str(e),
+                "type": "validation_error"
+            }
+        )
+    
+    # Execute the workflow
+    result = run_workflow(data)
+    
+    # Return appropriate HTTP status code based on workflow result
+    status_code = 200 if result["status"] == "success" else 500
+    
+    return JSONResponse(
+        status_code=status_code,
+        content=result
+    )
+
+@app.get("/openapi.json")
+async def get_openapi():
+    '''Get OpenAPI specification'''
+    from fastapi.openapi.utils import get_openapi
+    return get_openapi(
+        title="n8n2py Converted Workflow",
+        version="1.0.0",
+        description="API for converted n8n workflow",
+        routes=app.routes,
+    )
+
+if __name__ == "__main__":
+    import uvicorn
+    import os
+    
+    # Configuration
+    host = os.getenv("API_HOST", "0.0.0.0")
+    port = int(os.getenv("API_PORT", "8000"))
+    debug = os.getenv("API_DEBUG", "false").lower() == "true"
+    
+    print("🚀 Starting n8n2py converted workflow server...")
+    print(f"📖 API documentation: http://{host}:{port}/docs")
+    print(f"🔍 Health check: http://{host}:{port}/health")
+    print(f"⚡ Execute workflow: POST http://{host}:{port}/run")
+    
+    uvicorn.run(
+        app, 
+        host=host, 
+        port=port, 
+        reload=debug,
+        log_level="info"
+    )