Mar 20, 2025

Marketing Automation with ChatGPT

Learn how to automate marketing content across platforms using ChatGPT, LinkedIn and Meetup APIs to save time while maintaining a consistent online presence.

In today’s digital landscape, maintaining a consistent online presence is crucial for businesses looking to stay competitive. However, the demands of creating, scheduling, and posting content across multiple platforms can quickly become overwhelming, especially for business owners and executives who already have numerous responsibilities. In a recent OpenAI Application Explorers meetup, Godfrey Nolan, President at RIIS, demonstrated how ChatGPT can be used to help automate these once attention draining tasks.

As usual, you can follow along with the session video or read the tutorial below.

A Look Into RIIS Marketing Cycle

If you’ve been following the RIIS blog, YouTube, LinkedIn, or OpenAI Applications Explorers Meetup group, then you will have noticed all of those platforms cross-referencing each other. This is achieved in many ways through utilizing LLMs to in part generate and transform content. This very blog post is partially generated by AI, and we even wrote a post on how we do that.

This tutorial serves as a spiritual sequel, demonstrating our content workflow. You'll learn how we take a Meetup idea, generate content for it, post it to Meetup, and then create promotional posts for LinkedIn. Additionally, when we publish articles like this one on the RIIS blog, we automatically generate new social media posts to promote the article, creating an integrated content ecosystem.

The RIIS Marketing Schedule

Our marketing automation strategy follows a structured weekly schedule designed to maintain consistent engagement:

Monday: Post Meetup content to personal LinkedIn
Tuesday: Post Meetup content to company LinkedIn
Wednesday: Ad hoc posts (events, announcements, etc.)
Thursday: Post blog content to personal LinkedIn
Friday: Post blog content to the company's LinkedIn

This schedule ensures regular content distribution while still leaving room for spontaneous or event-based posts. We typically host two meetups per month—one focused on OpenAI and another on drone development. This creates a content ecosystem where each meetup ultimately produces two blog posts per month.

It may seem out of order, but first, we are going to start with automating the blog posts and then show you how to automate the Meetup promotional posts.

Automating Blog Posts to LinkedIn

The first automation workflow Nolan demonstrates is taking blog posts from the company website (riis.com) and posting them to LinkedIn. This process requires several key components:

1. Accessing the Blog’s RSS Feed

Most blogging platforms offer RSS (Really Simple Syndication) feeds, which are essential for this automation. “Depending on your platform, that’s usually just plugins,” Nolan explains. WordPress users can utilize an RSS plugin, while Framer (the platform RIIS uses) offers a similar SaaS plugin.

The RSS feed provides structured data including post titles, links, descriptions, and images—all of which are needed for creating LinkedIn posts.

2. Parsing the RSS Feed

To extract the necessary information from the RSS feed, Nolan uses Python with the feedparser library. This allows him to pull the title, link, and image URL from the most recent blog post:

import feedparser
# Parse the RSS feedfeed = feedparser.parse('https://www.riis.com/blog/feed')
latest_entry = feed.entries[0]
# Extract the information we needtitle = latest_entry.title
link = latest_entry.link
image_url = latest_entry.image_url  # This depends on your RSS feed structure# Download the image for later useimport requests
response = requests.get(image_url)
with open('blog_image.png', 'wb') as f:
    f.write(response.content)

3. Generating the LinkedIn Post Content with ChatGPT

With the blog information extracted, the next step is using OpenAI’s ChatGPT to create a compelling LinkedIn post:

import openai
# Set your OpenAI API keyopenai.api_key = "your-api-key"# Create a message for ChatGPTmessages = [
    {"role": "system", "content": "You're a helpful marketing assistant. Use hashtags. Use any image URLs provided for context."},
    {"role": "user", "content": f"Create a LinkedIn post for our blog titled '{title}'. The link is {link}"}
]

# Get the response from ChatGPT
response = openai.chat.completions.create(
    model="gpt-4",
    messages=messages
)

# Extract the generated LinkedIn postlinkedin_post = response.choices[0].message.content
# Save the post to a file for later usewith open('linkedin_post.txt', 'w') as f:
    f.write(linkedin_post)

The system prompt can be enhanced to include examples of past posts, which helps train ChatGPT to better match the desired writing style. This technique allows the AI to more accurately replicate the voice and tone of previous content, creating consistency across posts.

4. Authenticating with LinkedIn

Before posting to LinkedIn, you need to set up authentication. This involves creating an app on LinkedIn’s developer platform (developer.linkedin.com) and obtaining an access token.

For companies, Nolan explains that you need to register an app, provide a logo and privacy policy, and get approval from the company page owner. You’ll also need to add several products to your LinkedIn app:

Sign In with LinkedIn using OpenID Connect
Advertising API
Share API

After setting up the app, you can generate an access token through LinkedIn’s OAuth tools.

Setting up Authentication

First, we need to set up authentication with LinkedIn's API.

import requests
import config
import json
from ln_oauth import auth, headers

# Set up authentication using your LinkedIn credentials
creds = {
    "client_id": config.LINKEDIN_CLIENT_ID,
    "client_secret": config.LINKEDIN_CLIENT_SECRET,
    "redirect_uri": "http://127.0.0.1:8080",
    "access_token": config.LINKEDIN_ACCESS_TOKEN
}

# Authenticate and get headers for API calls
access_token = auth(creds)  # Authenticate with LinkedIn API
headers = headers(access_token)  # Create properly formatted headers for requests

There are only a few things that need to be noted here. The ln_oauth module handles token generation and renewal, while the config is where you will store your oAuth credentials from before.

Getting Organization Information

When posting to a company page, you must identify the organization as the post author. This requires retrieving the organization URN:

def org_info(headers):
    '''
    Get organization information from LinkedIn
    '''
    response = requests.get('https://api.linkedin.com/v2/organizationAcls?q=roleAssignee&projection=(elements*(organization~))', headers=headers)
    data = response.json()
    org_info = data['elements'][0]['organization']
    return org_info
 
# Get organization URN to use as the author of the post
org_info = org_info(headers)
author = org_info

This function calls LinkedIn's organizationAcls endpoint, which returns information about the organizations you have access to. We extract the organization URN from the response, which will be used as the "author" of our post.

Uploading Images and Creating Posts

Next, we are going to use a dedicated function that handles both the image upload process and post-creation.

def upload_image_to_linkedin(image_path, text):
    # Step 1: Register the image upload
    register_upload_url = f"{API_BASE_URL}/assets?action=registerUpload"
    upload_data = {
        "registerUploadRequest": {
            "owner": author,  # Using organization as owner
            "recipes": ["urn:li:digitalmediaRecipe:feedshare-image"],
            "serviceRelationships": [
                {
                    "identifier": "urn:li:userGeneratedContent",
                    "relationshipType": "OWNER",
                }
            ],
            "supportedUploadMechanism": ["SYNCHRONOUS_UPLOAD"],
        }
    }
    
    response = requests.post(register_upload_url, json=upload_data, headers=headers)
    response.raise_for_status()
    upload_info = response.json()
    
    upload_url = upload_info["value"]["uploadMechanism"]["com.linkedin.digitalmedia.uploading.MediaUploadHttpRequest"]["uploadUrl"]
    asset = upload_info["value"]["asset"]

Here's what's happening in this first part:

We register an upload with LinkedIn's assets API, specifying:
- The organization as the owner (not a personal profile)
- The recipe type as "feedshare-image" (for posting images to the feed)
- A synchronous upload mechanism for immediate processing

LinkedIn responds with an upload URL and an asset URN that we'll use later.

    with open(image_path, "rb") as image_file:
        upload_response = requests.put(upload_url, data=image_file)
        upload_response.raise_for_status()

In this section, we are taking the image file in binary mode, sending the binary data to the upload URL provided by LinkedIn, and doing a small error check. If you have ever uploaded an image file to AWS, you are probably familiar with this binary upload method.

Okay, we’re moving along piecing things together, now we need to start composing the post with all this data collected:

# Step 3: Create a post with the uploaded image
    post_url = f"{API_BASE_URL}/ugcPosts"
    post_data = {
        "author": author,
        "lifecycleState": "PUBLISHED",
        "specificContent": {
            "com.linkedin.ugc.ShareContent": {
                "shareCommentary": {"text": text},
                "shareMediaCategory": "IMAGE",
                "media": [{"status": "READY", "description": {"text": text}, "media": asset}],
            }
        },
        "visibility": {"com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC"},
    }
    
    post_response = requests.post(post_url, json=post_data, headers=headers)
    post_response.raise_for_status()
    print("Image uploaded and post created successfully!")

Now, we create the actual LinkedIn post by specifying the organization as the author, setting the post to be published immediately, including the ChatGPT-generated text as the post content, referencing the uploaded image asset, and setting the post visibility to public. This completes the process of creating a company post with both text and visual content.

Executing the Process

The final step is to read the ChatGPT-generated post and execute the function.

# Read in the text from linkedin_post.txt
with open("linkedin_post.txt", "r", encoding='utf-8') as file:
    post_text = file.read().strip()

# Execute the function with the image and text
upload_image_to_linkedin("image.png", post_text)

We read the post text from the file, then call our function with the image path and the post text.

If everything executes as intended, you should have a fresh new LinkedIn post in your feed.

Automating Meetup.com to LinkedIn

The Meetup workflow adds a few more layers, taking event information from Meetup.com and posting it to LinkedIn. This workflow follows similar steps to the blog-to-LinkedIn process but requires different API interactions.

1. Authenticating with Meetup.com

To authenticate with Meetup.com, you need to:

Pay for a Pro version of Meetup.com
Create OAuth credentials in your Meetup.com settings
Follow the OAuth flow to get an access token

If you are successful you should have a Key, a Secret, and a Redirect URL. The Redirect URL’s callback is what is going to give us our access token. This process is more cumbersome than you may be used to. The code below will help you retrieve the access token.

from flask import Flask, request, redirect
import requests
import config

app = Flask(__name__)

# Configuration
CLIENT_ID = config.MEETUP_CLIENT_ID
CLIENT_SECRET = config.MEETUP_CLIENT_SECRET
REDIRECT_URI = 'http://127.0.0.1:5000/oauth2/callback'
MEETUP_AUTH_URL = 'https://secure.meetup.com/oauth2/authorize'
MEETUP_TOKEN_URL = 'https://secure.meetup.com/oauth2/access'

@app.route('/')
def home():
    # Redirect the user to Meetup's authorization page
    auth_url = (
        f"{MEETUP_AUTH_URL}?client_id={CLIENT_ID}&response_type=code&redirect_uri={REDIRECT_URI}"
    )
    return f'<a href="{auth_url}">Connect with Meetup</a>'

@app.route('/oauth2/callback')
def oauth_callback():
    # Retrieve the authorization code from the callback
    authorization_code = request.args.get('code')
    if authorization_code:
        # Exchange the authorization code for an access token
        token_response = requests.post(
            MEETUP_TOKEN_URL,
            data={
                'client_id': CLIENT_ID,
                'client_secret': CLIENT_SECRET,
                'grant_type': 'authorization_code',
                'redirect_uri': REDIRECT_URI,
                'code': authorization_code,
            },
        )
        if token_response.status_code == 200:
            access_token = token_response.json().get('access_token')
            return f'Access token: {access_token}'
        else:
            return 'Failed to obtain access token.', 400
    else:
        return 'Authorization code not found.', 400
    

if __name__ == '__main__':
    app.run(debug=True)

2. Querying Meetup.com for our latest meeting info

Once you have your access token, you can use Meetup.com's GraphQL API to retrieve information about your upcoming events. The implementation follows these steps:

import requests
import config 
from openai import OpenAI
from datetime import datetime
from ln_oauth import auth, headers

# get the data from meetup.com (just one group for now)
ACCESS_TOKEN = config.MEETUP_ACCESS_TOKEN
# GraphQL query
query = 'query { groupByUrlname(urlname: "practical-chatgpt-api-programming") { name id upcomingEvents(input: {first: 1}) { pageInfo { hasNextPage hasPreviousPage startCursor endCursor } count edges { cursor node { id title eventUrl images { id baseUrl preview } venue { name } dateTime duration timezone endTime isOnline shortUrl } } } } }'
url = 'https://api.meetup.com/gql'
headers = {
    'Authorization': f'Bearer {ACCESS_TOKEN}',
    'Content-Type': 'application/json',
}

payload = {
    'query': query
}
response = requests.post(url, json=payload, headers=headers)

This code queries the Meetup GraphQL API for information about the most recent upcoming event from the "practical-chatgpt-api-programming" group. The query is structured to retrieve detailed information about the event, including its title, URL, date/time, and associated images.

Once we have the response, we need to parse it into a usable format:

# Extracting required data
def parse_meetup_data(data):
    parsed_data = []
    group = data.get('data', {}).get('groupByUrlname', {})
    name = group.get('name', 'N/A')
    upcoming_events = group.get('upcomingEvents', {}).get('edges', [])

    for event in upcoming_events:
        node = event.get('node', {})
        title = node.get('title', 'N/A')
        short_url = node.get('shortUrl', 'N/A')
        date_time = node.get('dateTime', 'N/A')

        # Format the dateTime
        formatted_date_time = "N/A"
        if date_time != 'N/A':
            dt = datetime.strptime(date_time, "%Y-%m-%dT%H:%M%z")
            formatted_date_time = dt.strftime("%B %d").replace(" 0", " ") + ", at " + dt.strftime("%I%p").lstrip("0").lower()

        images = node.get('images', [])
        image_data = [
            {
                'image_id': img.get('id', 'N/A'),
                'base_url': img.get('baseUrl', 'N/A')
            } 
            for img in images
        ]

        parsed_data.append({
            'name': name,
            'title': title,
            'shortUrl': short_url,
            'dateTime': formatted_date_time,
            'images': image_data
        })

    return parsed_data

This parsing function extracts key information from the API response and formats it for use:

Group name and event title
The event's short URL for sharing
Date and time formatted in a user-friendly way (e.g., "March 5, at 7 pm")
Image information, including base URLs and IDs

Next, we prepare this data for ChatGPT and download the event image:

# Parsing and displaying the data
parsed_data = parse_meetup_data(response.json())
openai_user_message = "Create a LinkedIn post for the upcoming meetup event with the following information:"
for event in parsed_data:
    openai_user_message += f"Group Name: {event['name']}\n"
    openai_user_message += f"Event Title: {event['title']}\n"
    openai_user_message += f"Short URL: {event['shortUrl']}\n"
    openai_user_message += f"DateTime: {event['dateTime']}\n"
    for img in event['images']:
        # openai_user_message += f"Img: {img['base_url']}{img['image_id']}\n"
        url = f"{img['base_url']}{img['image_id']}"
        try:
            # Send a GET request to the URL
            response = requests.get(url, stream=True)
            # Check if the request was successful
            if response.status_code == 200:
                # Open the file in write-binary mode and write the content
                with open("image.png", "wb") as file:
                    for chunk in response.iter_content(chunk_size=1024):
                        file.write(chunk)
                print(f"Image successfully downloaded")
            else:
                print(f"Failed to retrieve the image. Status code: {response.status_code}")
        except Exception as e:
            print(f"An error occurred: {e}")

print(openai_user_message)

This section constructs our prompt for ChatGPT with the event details for additional context., then it downloads the event image by combining the base URL and image ID. The image is saved as "image.png" for later use when posting to LinkedIn.

With the event information collected and the image downloaded, we're ready to pass this information to ChatGPT to generate the LinkedIn post:

# get ChatGPT to generate a linkedin post
client = OpenAI(api_key=config.OPENAI_API_KEY)
openai_response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful marketing assistant. Use hashtags. Use any image URLs provided for context."},
        {"role": "user", "content": openai_user_message},
    ]
)
print(openai_response.choices[0].message.content)

with open('linkedin_post.txt', 'w', encoding='utf-8') as file:
    file.write(openai_response.choices[0].message.content)
# post it to linkedin - step6.py

This code uses OpenAI's API to generate a LinkedIn post based on the Meetup event information. It sets up a system prompt like in our previous flow to act as a marketing assistant and provides the event details in the user message. Finally, it saves the generated post to a file named "linkedin_post.txt" with UTF-8 encoding to handle special characters.

4. Posting to the Company LinkedIn Page

Similarly to before, create a new app on LinkedIn and retrieve your oAuth token. Reuse the code in section 5 of the RSS to LinkedIn flow to make your API call, but update the config variables so they go to the new app you made for the Meetup to LinkedIn flow rather than the old one. If you’ve done everything correctly, you should see something like this in your feed!

Automating the Process with Cron Jobs

Once the automation scripts are working properly, it's recommended to deploy them as cron jobs to run automatically on schedule. Using a hosting service like render.com, which costs about $10 per month, provides a convenient way to host these scripts and set up cron schedules.

AI tools can help create the cron expressions needed. For example, asking an AI to "write me the cron expression for 11 a.m. Monday" yields the necessary configuration without needing to remember the syntax.

For each scheduled post in a weekly routine, it's best to set up separate cron jobs to execute the appropriate script. The requirements.txt file should include all necessary dependencies like feedparser, requests, and openai to ensure the automation runs smoothly.

When first implementing this system, a semi-manual approach where content is reviewed before going live is recommended. gradually transitioning to fully automated posting once confident in the quality allows the system to generate messages and post to LinkedIn independently. This graduated approach helps ensure the content matches the intended voice and quality standards.

Conclusion

Congratulations! You've now learned how to build a powerful marketing automation system that can significantly reduce the time and effort needed to maintain your social media presence. Through this tutorial, you've gained valuable skills in setting up RSS feed automation, working with LinkedIn and Meetup APIs, using ChatGPT to generate engaging content, processing data from multiple sources, handling images for social posts, and scheduling automation with cron jobs. This system creates a continuous flow of content that cross-promotes your various platforms while maintaining a consistent voice. As you continue to refine your approach, consider experimenting with different prompts for ChatGPT to find the perfect tone for your audience, and remember even if you’re automating, never lose that human touch and take the extra time you save to connect with your audience!