DEV Community: Vaibhav Maurya

How I Automated Instagram Posts from Google Drive Uploads Using n8n

Vaibhav Maurya — Sat, 05 Jul 2025 06:30:00 +0000

When you're posting 5-6 posts per day on multiple accounts, you obviously can't be posting at night while sleeping. Work-life balance is important, right? I know it's hard to believe these kinds of scenarios actually work, but it really depends on your use case.

What you'll need
Why n8n?
First Workflow - Monitoring File Uploads
Second Workflow - Active Posting
Done!

I built this automation system for posting across multiple Instagram accounts. The setup is pretty straightforward once you understand the flow.

Here's how it works: Users upload video files to a specific Google Drive folder. The first n8n workflow continuously monitors this folder and updates a spreadsheet record. The second workflow handles the actual posting at scheduled intervals.

What you'll need

Google Drive folder for video uploads
Connected Google Sheets for record keeping
Two n8n workflows (one for monitoring, one for posting)
Instagram Post API access
Server or domain to host your n8n instance

Why n8n?

n8n is perfect for small workflows, though you can definitely build complex ones too. It's easy to use and developer-friendly. Similar to Zapier but better in my opinion. The main reason I chose it was that we already had an n8n server running with some existing workflows.

Problem: How do we get descriptions for the posts?

First Workflow - Monitoring File Uploads

Step 1: Create a workflow with a suitable name.

Step 2: Add a schedule trigger node. This triggers the workflow at every interval.

Step 3: Format the date here. I find the fromDate and toDate values. Since we fetch file info from Google Drive, we need to make sure we don't fetch files that have already been processed. So we only fetch files within that time interval.

Step 4: Get Google OAuth credentials:

Go to Google Console
Create a new project
Navigate to the Credentials section
Search for Google Drive API and Google Sheets API and enable them
Generate OAuth 2.0 Client ID and API Key - save these for later

Step 5: Add Google Drive Node:

Configure your credentials
Create a new folder in Google Drive and add the folder name here
Add the folder name and filter query string like: createdTime > '{{ $json.fromDate }}' and createdTime < '{{ $json.toDate }}'

Step 6: Extract content using Code Node:

Posts Description Problem: This can be fixed by setting the description in the file name. Just remove the extension from the file name. Simple, right? 😁

Since n8n doesn't provide createdAt, we set the current date here.

function removeExtension(filename) {
  return filename.replace(/\.[^/.]+$/, "");
}

const data = $input.all();
const sheetData = data.map(({json}) => {
  const name = removeExtension(json.name);
  return {...json, name, createdAt: $('Format Date').first().json.toDate};
})

return sheetData;

Step 7: Save to Google Sheets:

I chose Google Sheets because it's easy to connect and use in workflows.

Create a spreadsheet with these columns:

id
name
createdAt
mimeType
trashed
isPostedProviderOne
isPostedProviderTwo
isPostedProviderThree
isPostedProviderFour
isPostedProviderFive
webViewLink

Add the Google Sheets node, use the same credentials, choose "append row" operation, and select your spreadsheet.

That's it for the first workflow. Now let's implement the second workflow.

Second Workflow - Active Posting

Step 1: Create a new workflow for posting.

Step 2: Add a schedule trigger node and set the interval according to your needs.

Step 3: Fetch all files from the spreadsheet.

Step 4: Add a Code node with the core logic:

Here's what I implemented:

Every day, each account posts unique content
Each provider posts 5-6 posts daily
Once a video is published on one account, other accounts won't post the same video on the same day

const files = $input.all();
const today = new Date().toISOString().split("T")[0];
const apiKey = "google-oauth-api-key";
const provider = "INSTAGRAM";

// Provider IDs - you'll get these from successful Instagram OAuth
const providerIds = {
  isPostedProviderOne: "account-id-1",
  isPostedProviderTwo: "account-id-2",
  isPostedProviderThree: "account-id-3",
  isPostedProviderFour: "account-id-4",
  isPostedProviderFive: "account-id-5"
};

const posts = [];
const usedFilesToday = new Set();
const usedProvidersToday = new Set();
const providersEverUsed = new Set();

const isPostedToday = (dateStr) =>
  typeof dateStr === "string" && dateStr.startsWith(today);

for (const { json } of files) {
  const { id, name, ...providerStatuses } = json;
  if (!id || usedFilesToday.has(id)) continue;

  const providerSlots = Object.entries(providerStatuses)
    .filter(([key]) => key.startsWith("isPostedProvider"));

  const alreadyPostedToday = providerSlots.some(([, value]) =>
    isPostedToday(value)
  );
  if (alreadyPostedToday) continue;

  for (const [key, value] of providerSlots) {
    if (value?.trim()) {
      providersEverUsed.add(key);
      continue;
    }

    if (usedProvidersToday.has(key) || providersEverUsed.has(key)) continue;

    posts.push({
      key,
      rawData: json,
      postData: {
        id: `snapshot-${id}`,
        version: 1,
        content: name,
        contentRaw: name,
        status: "DRAFT",
        plannedFor: null,
        mediaUrls: [
          `https://www.googleapis.com/drive/v3/files/${id}?alt=media&key=${apiKey}`
        ],
        parentId: null,
        selectedText: null,
        style: null,
        prompt: null,
        mediaMetadata: null,
        jobId: null,
        publishJobId: null,
        postId: `post-${id}`,
        providerId: providerIds[key],
        provider,
        post: { postType: "INSTAGRAM_REELS" }
      }
    });

    usedFilesToday.add(id);
    usedProvidersToday.add(key);
    providersEverUsed.add(key);
    break; // Only assign one provider per file
  }

  if (posts.length >= 5) break;
}

return posts;

Step 5: Since I'm using our project internal API for Instagram posting, the content is formatted accordingly. Instagram Post API will be covered in upcoming blog posts. You can write your own API post logic here.

The output looks like this:

[
  {
    "key": "isPostedProviderTwo",
    "rawData": {
      "row_number": 2,
      "id": "1NG0TFK1sp3AjOY3710yiOnSNvGQoUneF",
      "name": "This is place where boats get lift #boat",
      "createdAt": "2025-07-03T11:15:30.007Z",
      "mimeType": "video/mp4",
      "trashed": false,
      "isPostedProviderOne": "2025-07-03T11:18:24.819Z",
      "isPostedProviderTwo": "",
      "isPostedProviderThree": "",
      "isPostedProviderFour": "",
      "isPostedProviderFive": "",
      "webViewLink": "https://drive.google.com/file/d/1NG0TFK1sp3AjOY3710yiOnSNvGQoUneF/view?usp=drivesdk"
    },
    "postData": {
      "id": "snapshot-1NG0TFK1sp3AjOY3710yiOnSNvGQoUneF",
      "version": 1,
      "content": "This is place where boats get lift #boat",
      "contentRaw": "This is place where boats get lift #boat",
      "status": "DRAFT",
      "plannedFor": null,
      "mediaUrls": [
        "https://www.googleapis.com/drive/v3/files/1NG0TFK1sp3AjOY3710yiOnSNvGQoUneF?alt=media&key=api-key"
      ],
      "parentId": null,
      "selectedText": null,
      "style": null,
      "prompt": null,
      "mediaMetadata": null,
      "jobId": null,
      "publishJobId": null,
      "postId": "post-1NG0TFK1sp3AjOY3710yiOnSNvGQoUneF",
      "providerId": "sdfsdfsdf",
      "provider": "INSTAGRAM",
      "post": {
        "postType": "INSTAGRAM_REELS"
      }
    }
  }
]

Step 6: Add a "Loop Over Items" node so we can iterate over all the items.

Step 7: Add an "HTTP Request" node to make the API request for posting.

Step 8: Once successful, add another Code node to update the current date for the selected provider:

return {
  ...$('Loop Over Items').first().json.rawData,
  [$('Loop Over Items').first().json.key]: `${new Date().toISOString()}`
}

Step 9: Add Google Sheets node, select "Update Row" operation by ID.

Done!

I know it's a bit tricky if you don't know about n8n, but it's easy once you get started. This will definitely save you time. Whenever you're done with video creation, just upload it to Google Drive. No need to worry about the posting process. You can even customize it if you want posts to go live at specific times every day.

If you enjoyed this post or learned something new, feel free to connect with me on GitHub, Twitter or LinkedIn. I often share dev stories, lessons, and mistakes — so follow along for more! 🚀👨‍💻✨

Yes, I'm an SDE. No, I Didn't Know About WWW-Authenticate 😩

Vaibhav Maurya — Wed, 02 Jul 2025 06:30:00 +0000

Hey everyone! I experienced this last week, and today I'm here to share it with you. I was like, "Why don't I know such a simple topic?" 🤯

I was building a SaaS website using Next.js. One of the pages required Basic Header Authentication. I started working on creating a UI and the business logic for it. Once I submitted the PR, a few hours later, I received…

Since the project was built on Next.js, we could've implemented JWT or token-based authentication, but that would've been too complex for just a single page.

I feel like there are many developers like me who don't know about Basic Auth - and that's okay. We're all learning.

What is Basic Header Authentication? Why was it chosen? Should freshers and junior developers know this?

This topic isn't even covered in most courses or tutorials. That's why it's important to understand it. So let's explore the answers to all of these questions.

What is Basic Header Authentication?

Basic Header Authentication was developed by Ari Luotonen in 1993 and was later added to the HTTP 1.0 specification in 1996. It is a straightforward method of authentication, and the amazing part is that it doesn't require any client-side code at all.

When the browser makes a request for the first time, the server responds with a 401 Unauthorized status and includes an authentication header. The browser then automatically shows a popup asking the user for their username and password — no need to build a login UI!

Once the user enters their credentials, the browser encodes them using Base64, attaches them to the next request, and sends it back to the server. The server then decodes and compares the credentials. If they're valid, the user gets access.

Simple, right? 😄

Why was it chosen?

Simple to implement.
No client-side code required.
Prefect for small use cases where authentication isn’t critical.

Should freshers and junior developers know this?

Yes, absolutely!

In fact, I wish someone had told me earlier.

If you're working on a small project, an admin panel, or an internal tool where security isn't a top concern, Basic Header Authentication can be a perfect fit. It's rarely covered in tutorials or bootcamps, but it still exists in real-world projects — and knowing it can save your time.

Plus, you don't need to write a single line of frontend login logic. That's a win.

Let's walk through a basic implementation:

When you enter your credentials in the browser popup, the browser does the following:

Encodes the string username:password using Base64.
Sends a request to the server with an HTTP header that looks like this:
```
Authorization: Basic <base64-encoded-credentials>
```
For example, if your username is admin and password is 1234, the header would look like:
```
Authorization: Basic YWRtaW46MTIzNA==
```
The server then:
- Decodes the Base64 string
- Verifies the username name password
- Grants access if valid

That’s it! No sessions, no cookies, no frontend login forms - just plan HTTP headers and built-in browsers behaviours.

const express = require('express');
const app = express();

// Replace with your actual credentials
const USERNAME = 'admin';
const PASSWORD = '1234';

const basicAuthMiddleware = (req, res, next) => {
  const authHeader = req.headers.authorization;

  // If Authorization header is missing
  if (!authHeader || !authHeader.startsWith('Basic ')) {
    res.setHeader('WWW-Authenticate', 'Basic realm="Protected Area"');
    return res.status(401).send('Authentication required.');
  }

  // Decode base64 credentials
  const base64Credentials = authHeader.split(' ')[1];
  const credentials = Buffer.from(base64Credentials, 'base64').toString('utf-8');
  const [username, password] = credentials.split(':');

  // Validate credentials
  if (username === USERNAME && password === PASSWORD) {
    next(); // Auth success
  } else {
    res.setHeader('WWW-Authenticate', 'Basic realm="Protected Area"');
    return res.status(401).send('Invalid credentials.');
  }
};

So that was my humbling (but fun) experience with Basic Header Authentication. It may be old-school, but it's still relevant — especially when you just need a quick and simple layer of protection without diving into the complexity of modern auth systems like JWT or OAuth.

Honestly, I learned this the hard way — after building something way more complex than necessary. But now that you know about WWW-Authenticate, you won't make the same mistake. And if someone laughs and says, "LOL! This won't work," just hit them with that Authorization: Basic magic. 💪