AI generator of a weekly content plan from a website URL

Creating a meaningful weekly content plan is often a surprisingly time-consuming discipline. It is not just about generating a few ideas for articles or social media posts. The real problem lies elsewhere: quickly understanding what the website is about, what audience it addresses, what language it uses to communicate, and which topics make sense specifically for its content strategy. This is exactly where the practical use of artificial intelligence comes in. If AI receives properly prepared data from a specific website, it can use it to propose a usable weekly content plan instead of generic, interchangeable recommendations.

In this guide, we will build a functional MVP of a project that automatically performs a basic content analysis from a single website URL and returns a proposal of topics for the entire week. The goal is not to build a full-fledged enterprise platform, but a feasible system that can be deployed within a few hours and expanded further. We will use real services, specific interface steps, exact inputs, prompt examples, and measurable outputs. The process is designed so that even a less advanced reader can handle it.

Project goal

Try NordVPN

The goal of the project is to create a simple automation that, after entering a website URL, performs these tasks:

• loads the content of the homepage and selected subpages,
• extracts key topics, products, services, and tone of communication,
• proposes a weekly content plan for 7 days,
• adds a format, working title, brief summary, and CTA for each day,
• saves the output to a spreadsheet or database so it can be worked with further.

The result will be an MVP that can return a clear publishing plan from a single website URL, for example for a blog, LinkedIn, or a newsletter. If you have your own website, you can use the system immediately. If you are an agency or freelancer, the same process can be used for a quick initial audit of a client website.

Prerequisites

Try Semrush

Before we begin, prepare a few specific tools. In this guide, we will use services that have official documentation and are commonly available:

• OpenAI API for text analysis and topic suggestions: https://platform.openai.com/
• Firecrawl for downloading and extracting website content: https://www.firecrawl.dev/
• Make for workflow automation without the need to build a full backend API from scratch: https://www.make.com/
• Google Sheets as a simple results storage: https://www.google.com/sheets/about/

You will also need:

• an OpenAI API key,
• a Firecrawl API key,
• a Google account for Sheets,
• a Make account with access to HTTP modules and Google Sheets.

If you are not sure about the limits of individual plans, treat them as constraints. Prices, quotas, and feature availability may change, so always verify them in the official documentation of the specific service.

Implementation steps

Try Hostinger

Step 1: Prepare the input sheet and define what the system will process

What and why: First, we need to clearly determine where the URL will come from and where the results will be stored. Without a stable input structure, the automation will soon fall apart. For an MVP, Google Sheets is the most practical option because it allows manual URL entry and quick output review.

Exactly how: In Google Sheets, create a new file and name the first sheet Inputs. In the first row, insert the columns:

web_url | brand_name | channel | country | language | status

Example row:

https://example.com | Example | LinkedIn | CZ | cs | new

Then add a second sheet named ContentPlan and insert these columns:

web_url | day | topic | format | angle | brief | cta | source_pages | generated_at

Later in Make, you will set up the scenario so that it reads only rows where status = new.

Specific input: the web_url column with the value https://example.com.

Specific output: a prepared sheet with the input URL and a target sheet for 7 content plan items.

Success metric: the sheet contains at least 1 valid URL, 1 target communication channel, and the scenario has an unambiguous filter status = new.

Once we have the input structure, we can smoothly move on to collecting content from the website. Only from real text can AI understand what the website is actually about.

Step 2: Download website content via Firecrawl

What and why: The LLM needs text data. The URL alone is not enough. The goal of this step is to obtain readable text from the homepage and several relevant subpages without distracting elements. Firecrawl is suitable because it returns website content in a more structured form than plain HTML.

Exactly how: In Make, create a new scenario. Add the Google Sheets > Search Rows module and load rows from the Inputs sheet where status matches the value new. Then insert the HTTP > Make a request module.

HTTP module settings:

• Method: POST
• URL: https://api.firecrawl.dev/v1/scrape
• Headers:
  Authorization: Bearer YOUR_FIRECRAWL_API_KEY
Content-Type: application/json

Request body:

{
  "url": "{{1.web_url}}",
  "formats": ["markdown"],
  "onlyMainContent": true,
  "waitFor": 2000
}

If you want a more extensive analysis than just the homepage, use the crawl endpoint instead of /scrape according to the current Firecrawl documentation. For some websites, it may be necessary to adjust the crawl depth or the number of pages. This should be treated as a limitation given by the structure of the specific website and the service plan.

Example input: API parameter url = https://example.com.

Expected output: a field containing the page markdown text, for example:

# Example
We help companies automate marketing processes...
## Services
- SEO audit
- Content strategy

Success metric: the obtained text has at least 1500 characters or contains at least 3 sections with headings. If the returned content contains only navigation, a cookie bar, or fewer than 500 characters, consider the step unsuccessful.

Once we obtain the content, it is useful to shorten it and convert it into a clear analytical form before generating the plan. This reduces noise and the cost of further AI queries.

Step 3: Create an AI website analysis focused on topics and audience

What and why: Now we need to extract the essentials from the collected text: who the target audience is, what services or products the website offers, what topics it repeats, and what tone of communication it uses. This intermediate step is important because the content plan is then not created blindly, but from a specific analytical summary.

Exactly how: Add another HTTP > Make a request module in Make for the OpenAI API. Use the Responses API endpoint.

Settings:

• Method: POST
• URL: https://api.openai.com/v1/responses
• Headers:
  Authorization: Bearer YOUR_OPENAI_API_KEY
Content-Type: application/json

Example request body:

{
  "model": "gpt-4.1-mini",
  "input": [
    {
      "role": "system",
      "content": "You are a website content analyst. Return JSON only."
    },
    {
      "role": "user",
      "content": "Analyze this website content and return JSON with the structure: brand_summary, audience, products_services, main_topics, tone_of_voice, content_gaps. Website content:nn{{2.data.markdown}}"
    }
  ]
}

A practical mini prompt template for better consistency:

Determine:
1. a brief brand summary in 2 sentences,
2. the primary audience,
3. 5 main topics,
4. 3 content gaps,
5. the tone of communication in 3 adjectives.
Return valid JSON only.

Example input: the {{2.data.markdown}} field with text downloaded from Firecrawl.

Expected output:

{
  "brand_summary": "The company offers marketing automation for small and medium-sized businesses.",
  "audience": ["marketing managers", "e-shop owners"],
  "products_services": ["SEO audit", "content strategy"],
  "main_topics": ["SEO", "automation", "content marketing", "analytics", "lead generation"],
  "tone_of_voice": ["expert", "practical", "clear"],
  "content_gaps": ["missing case studies", "little content for LinkedIn", "missing evergreen guides"]
}

Success metric: the output is valid JSON and contains at least 4 items in the main_topics field. If the model returns free text instead of JSON, adjust the prompt with the explicit instruction Return only valid JSON without commentary.

Now AI already knows what the website offers and which topics make sense. The next logical step is to turn this analysis into a specific seven-day plan.

Step 4: Generate a weekly content plan for 7 days

What and why: In this step, we will create a real publishing plan from the analytical data. Each day must have a clear topic, format, and purpose. To make the output immediately usable, we will also add a brief summary and CTA.

Exactly how: Add another OpenAI API call in Make. Do not insert only the raw website content into the prompt, but mainly the previous analytical JSON. This will increase result consistency and reduce unnecessary input length.

Example request body:

{
  "model": "gpt-4.1-mini",
  "input": [
    {
      "role": "system",
      "content": "You are a content strategist. Return only a valid JSON array of 7 objects."
    },
    {
      "role": "user",
      "content": "Based on this website analysis, propose a weekly content plan for the channel {{1.channel}} in the language {{1.language}}. Each item must contain: day, topic, format, angle, brief, cta, source_pages. Analysis: {{3.output_text}}"
    }
  ]
}

If you want to control the output more precisely, add a short rule template:

Rules:
- 7 days, Monday to Sunday
- do not repeat the same topic
- at least 2 educational formats and 1 conversion format
- brief max. 280 characters
- CTA max. 12 words

Example input: parameter channel = LinkedIn.

Expected output:

[
  {
    "day": "Monday",
    "topic": "How to recognize that a website needs a content audit",
    "format": "LinkedIn post",
    "angle": "educational",
    "brief": "Explain 5 signals that website content is not fulfilling a business goal.",
    "cta": "Request a quick audit",
    "source_pages": ["/", "/services"]
  }
]

Success metric: the output contains exactly 7 objects, each object has all 7 required fields, and at least 5 of the 7 topics are substantively different.

We have a plan proposal, but to make the project truly usable, we need to save the data in a clear form. That brings us to writing the results.

Step 5: Save the output to Google Sheets day by day

What and why: The result must not remain only in the API response. We need to write it down so it can be shared, edited, and possibly exported. Google Sheets is an ideal target storage for an MVP.

Exactly how: In Make, after the OpenAI module, insert the JSON > Parse JSON module. Insert the expected array structure with 7 objects into the schema. Then add the Tools > Iterator module, which will go through each content plan item separately. After that, insert Google Sheets > Add a Row.

Column mapping in the ContentPlan sheet:

• web_url = {{1.web_url}}
• day = {{5.day}}
• topic = {{5.topic}}
• format = {{5.format}}
• angle = {{5.angle}}
• brief = {{5.brief}}
• cta = {{5.cta}}
• source_pages = {{join(5.source_pages; ", ")}}
• generated_at = current date and time

At the same time, update the original row in Inputs using the Google Sheets > Update a Row module and set status = done.

Example input: a JSON array with 7 items from the previous step.

Expected output: 7 new rows are added to the ContentPlan sheet.

Success metric: after processing one URL, exactly 7 rows are created and the original row in Inputs switches to done.

We already have the output saved, but before deployment it is advisable to add one more safeguard. Not every generated plan is equally good, so it is worth automatically checking basic usability.

Step 6: Add automatic output quality control

What and why: AI can sometimes return overly generic topics, repetitive suggestions, or briefs with no connection to the website. Therefore, we will add a light validation layer. This is not a perfect evaluation, but a practical MVP check.

Exactly how: After plan generation, add one more OpenAI call or simple logic directly in Make. To start, I recommend AI validation with clear rules and a score.

Example validation prompt:

Evaluate this content plan on a scale from 0 to 100.
Criteria:
1. relevance to the website,
2. topic diversity,
3. practicality of briefs,
4. clarity of CTA.
Return JSON: overall_score, weak_items, recommendations.
Plan: {{4.output_text}}
Website analysis: {{3.output_text}}

Example expected output:

{
  "overall_score": 84,
  "weak_items": ["Wednesday is too generic", "Saturday has a weak CTA"],
  "recommendations": ["Specify the topic of the Wednesday post more precisely", "Add an action verb to the CTA"]
}

Then in Make, set up a router:

• if overall_score >= 75, continue to writing to the sheet,
• if overall_score < 75, send the plan back to generation with an additional prompt.

The additional prompt may look like this:

Adjust the content plan according to these comments: {{6.recommendations}}.
Return the full JSON array of 7 items again.

Specific input: the overall_score field.

Specific output: an approved plan or an automatically corrected second version.

Success metric: at least 80% of processed websites pass validation on the first or second attempt with a score of at least 75.

This completes the basic MVP. If you want to move the project from a one-time run to practical operation, deployment and regular execution follow next.

Recommended AI stack for implementation

Choose tools according to your budget and level of automation. Below is a direct overview of services for implementing the project.

Testing

Try Fiverr

Before switching the scenario to production mode, test it on three different types of websites:

• a corporate presentation website,
• an e-shop with categories,
• a content or magazine website.

For each test, monitor these checkpoints:

1. Content loading: verify that Firecrawl returns the main text and not just the menu or footer.
2. Analytical JSON: check whether it contains specific topics tied to the website.
3. Seven-day plan: assess whether the topics do not repeat and match the selected channel.
4. Writing to the sheet: verify that exactly 7 rows are created.

Practical test scenario:

Input:
web_url = https://example.com
channel = LinkedIn
language = cs

Expectations:
- the analysis contains 4 to 6 main topics,
- the content plan contains 7 days,
- each day has a topic, format, brief, and cta,
- the status in Inputs changes to done.

If you encounter a website that blocks crawling, do not consider it a flaw in the guide, but a practical limitation of the specific website, its technical setup, or access rules.

Deployment

Try Adobe

For the first production deployment, it is enough to set scheduled scenario execution in Make. At the top of the scenario, click Scheduling and choose, for example, the interval Every 1 hour. This way, the system will check the Inputs sheet every hour and process new rows.

Recommended operational settings:

• add a priority column in the input sheet if you want to process websites by importance,
• save error states in the error_message column,
• set up an email notification in Make when the scenario fails,
• limit the maximum number of processed websites per run to avoid unexpected consumption of API limits.

If you want to expand the project, you can add additional outputs, for example a separate sheet for headline suggestions, hashtags, or newsletter topics. However, that is not necessary for a functional MVP.

Limits

Try Canva

This project is practical and quick to implement, but it has several limitations that need to be stated explicitly:

• The quality of the output depends on the quality of the website. If the website is very brief or outdated, the topic suggestions will also be weaker.
• The crawler may not always load everything. Some websites block bots, load content only after JavaScript, or require login.
• AI does not guarantee factual correctness of marketing interpretations. Topic suggestions should be reviewed by a human before publication.
• A content plan is not the same as an editorial strategy. The MVP generates a usable weekly proposal, but it does not replace long-term planning, SEO analysis, or knowledge of business priorities.
• API prices and limits may change. This applies to OpenAI, Firecrawl, and Make.

If you need higher accuracy, it usually helps to expand the input with more subpages, add data from Search Console, or manually supplement the brand’s business priorities. But that is already the next phase of the project.

FAQ

Do I need to know how to code?

No. For the described MVP, basic work with Google Sheets and orientation in Make are enough. You mainly work with forms, modules, and field mapping.

Can I use a different tool instead of Make?

Yes, for example Zapier or your own backend. However, this guide uses Make because it works well with HTTP modules and spreadsheets.

Which model should I choose in OpenAI?

For an MVP, it makes sense to start with the gpt-4.1-mini model because it is usually a reasonable compromise between price and quality. If the model offering changes, verify the current recommendations in the official OpenAI documentation.

Can I generate a plan for a blog instead of LinkedIn?

Yes. You just need to change the input field channel to, for example, Blog and optionally add the required format in the prompt, such as “how-to article,” “comparison,” or “FAQ text.”

What if the website contains multiple languages?

For an MVP, it is better to enter the target language in the language field, for example cs, and explicitly insist on output in this language in the prompt. If the website is multilingual and the content is mixed, the analysis may be less stable.

How do I know the output is really usable?

The practical minimum is a simple manual check of three things: relevance of topics to the website, absence of repetition, and usability of the brief for an editor or marketer. That is why we also included automatic score validation in the workflow.

Recommended next step

Try NordVPN

Links in the article

• OpenAI
• https://www.firecrawl.dev/
• Make
• Google
• OpenAI
• Firecrawl
• Firecrawl Documentation
• Make
• Make
• Firecrawl – official website and documentation
• OpenAI
• NordVPN
• Semrush
• Hostinger
• Fiverr
• Adobe
• Canva
• Make
• Jasper

Sources of illustrative images

• Stock photo: source

The custom illustrative image was created using the OpenAI Images API.

Note: We use affiliate links for listed services. If you purchase through them, we may earn a commission at no extra cost to you.

Doporučení ke čtení

AI email summaries and automatic reply suggestions

When AI Doesn’t Help in a Team: 5 Scenarios Where It Increases Costs Instead of Saving Them

AI Act 2026 for small businesses in the Czech Republic: practical checklist before August

How to set up Canva AI for quick creation of branded materials