In this guide, I’ll show you how to install and use the Salesforce DX MCP Server inside Visual Studio Code (VS Code)so you can give AI agents direct access to your Salesforce orgs.

What is MCP?

The Model Context Protocol (MCP) is an open-source project from Anthropic. It standardizes how applications provide context to large language models (LLMs).

Instead of your AI assistant “guessing” what’s in your Salesforce project, MCP gives it structured tools to securely access real project data.

With MCP, AI agents can:

• Query your Salesforce orgs
• Deploy and retrieve metadata
• Run unit tests
• Assign permission sets
• And much more

This makes your AI assistant smarter, more accurate, and actually useful in your Salesforce workflow.

Installing MCP in VS Code

There are two easy ways to install MCP in Visual Studio Code:

1. Visit the official MCP download page
2. Or install it directly inside the editor via the Command Palette

MCP servers can run locally or remotely. In this tutorial, we’ll keep it simple and run the Salesforce DX MCP Server locally – source code available from github at https://github.com/salesforcecli/mcp

Salesforce DX MCP Server Overview

The Salesforce DX MCP Server is a specialized MCP implementation designed for Salesforce developers.

• It uses the same OAuth flow as the Salesforce CLI (SFDX), so setup is seamless if you already work with SFDX.
• It’s currently available in beta, with new tools rolling out frequently.

Current Toolset (Beta)

Here are the MCP commands you can try today:

• Core: sf-get-username
• Orgs: sf-list-all-orgs
• Data: sf-query-org
• Users: sf-assign-permission-set
• Metadata: sf-deploy-metadata, sf-retrieve-metadata
• Testing: sf-testing-agents, sf-test-apex

Step-by-Step Setup in VS Code

Here’s how to get started with the Salesforce DX MCP Server:

Code snippet from Salesforce official Github repo – check for more information https://github.com/salesforcecli/mcp

{
  "servers": {
    "Salesforce DX": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@salesforce/mcp", "--orgs", "DEFAULT_TARGET_ORG", "--toolsets", "all"]
    }
  }
}

1. Open VS Code
2. Create a new Salesforce DX (SFDX) project
3. Authenticate your org
4. Then add the MCP Server
5. Open the Command Palette (CMD+Shift+P on Mac or CTRL+Shift+P on Windows)
6. Use the MCP setup wizard or create a mcp.json file inside your .vscode folder
7. Paste the code above, save and hit Start on the context menu
8. If you’re on GitHub Copilot Enterprise, confirm with your admin that MCP is enabled (some enterprise setups restrict it)
9. Once running, open the AI chat and try commands like:
   • “How many users are admins?”
   • “How many orgs are authenticated?”
   • “Retrieve all Apex classes from this org”
   • “Run all unit tests”

That’s it — your AI assistant now has real Salesforce context.

Why Salesforce DX MCP Matters

The Salesforce DX MCP Server makes it possible to combine Salesforce development with AI-powered productivity. Instead of manually checking metadata, running queries, or handling org management, you can let AI agents perform these tasks securely with full project awareness.

This is still early days — the toolset is in beta — but it’s clear that MCP will play a huge role in the future of Salesforce AI development.

Conclusion

The Salesforce DX MCP Server is a game-changer for developers looking to bring AI into their Salesforce workflow. By running it in VS Code, you can give AI assistants direct, secure access to your org and metadata, making them far more useful than before.

For a full walkthrough, check out my video tutorial here: 

If you have a specific use case for MCP that you’d like me to try, drop a comment — I’ll be covering more advanced setups soon.

The post How to Use the Salesforce DX MCP Server in VS Code appeared first on Just Another Dang Blog.

When Salesforce introduced Agentforce in September 2024 at Dreamforce, it marked a pivotal shift from traditional “copilots” to autonomous AI agents embedded across its ecosystem (Salesforce Developers. Since then, Salesforce Help alone has seen Agentforce handle over 1 million support requests, freeing up human teams to focus on more complex issues (Salesforce).

What Is Agentforce?

At its core, Agentforce is Salesforce’s next-generation AI platform that enables the creation of autonomous agents capable of understanding intent, planning multi-step tasks, and executing actions—either independently or with light human oversight.

This isn’t just another chatbot—it’s a tool that reasons and connects with your Salesforce data (via Data?Cloud), workflows, and external systems to drive real outcomes.

Key Capabilities — Simplified

1. Autonomous Agents

Agents can drive tasks like lead qualification, case triaging, email drafting, or meeting scheduling—with or without human prompts.

2. Low code Agent Builder

You don’t need to code to start. Use out-of-the-box templates, customize topics and actions, or connect flows, Apex or external services to empower your agent.

3. Integrated with Salesforce Ecosystem

Agentforce works across Sales Cloud, Service Cloud, Marketing Cloud, Slack, MuleSoft, and connects to Data Cloud for rich, contextual data access and reasoning.

4. Secure & Trustworthy

Powered by Salesforce’s Einstein Trust Layer, agents operate within existing security models and don’t store sensitive data—they act carefully and compliantly.

Real Results at Scale

On Salesforce.com, Agentforce has powered 100K+ conversations, influenced roughly 30K sales leads, and is now surfacing relevant conversion prompts during chats — guiding users to demos or trials at the right moments.

Internally, on Salesforce Help, the AI resolved routine support cases—over one million of them—allowing customer support engineers to focus on complex issues and strategic customer engagement.

Tips for Building Your First Agent

Salesforce’s customer success teams recommend:

Tip 1: Start with customer pain points, not AI features. Define the tedious or repetitive questions users ask, then build agents to address those.

Tip 2: Build using topics, actions & instructions. These drive agent behavior, guiding how it reasons and what tasks it performs.

Use AI Assist in the Agent Builder to help craft clearer instructions and topic definitions—especially helpful if outputs feel off or inconsistent.

My Step-by-Step Starter Approach

Pre?requisite: Assign Agentforce Permission Sets to Admins

Before you enable Agentforce, make sure the System Administrator (or any user managing agents) has the necessary permission set licenses and permission sets:

• Assign the Einstein Agent license to the admin user, which is required to allow assignment of Agentforce permission sets.
• In Setup > Permission Sets, assign the “Agentforce Default Admin” permission set and the “Prompt Template User” permission set to the admin or agent-building user.

1. Enable Agentforce in Setup (Enable Einstein and Agentforce toggles) (Salesforce Developers)
2. Open Agent Builder and create a starter topic (e.g., “Lead Qualification”) and attach actions like drafting emails or querying records (Salesforce Developers)
3. Use AI Assist to refine instructions
4. Test your agent in the conversation preview or via sidebar interaction in Salesforce
5. Launch and monitor – check analytics and fine-tune topics or triggers over time

Final Thoughts

Getting started with Agentforce can feel intimidating, but its low-code interface, integrated reasoning engine, and secure design make it accessible for admins, sales teams, and businesses alike.

It’s not just another chatbot—it’s a smarter way to automate routine workflows, scale your team’s bandwidth, and deliver faster, more intelligent experiences.

The post Getting Started with Salesforce Agentforce: What I Learned appeared first on Just Another Dang Blog.

This is usually caused by line-ending format on the raw csv file. On my Mac machine this should be LF and CRLF on Windows. To fix this you can use a text editor tool like VS Code or Sublime Text.

VS Code, open the .csv file and open the Command Pallete menu (Command+Shift+P keys for Mac), search for “Change End of Line Sequence” and set it to LF or CRLF for windows and save. That’s it, when uploaded to Salesforce it should detect the right line-ending.

If your using sf data tree, upload your file from the cli.

sf data upsert bulk --sobject Supply_Service__c --file con-update.csv --external-id GT_Consumer_Number__c

The post How to Fix Salesforce Bulk API Error – ClientInputError : LineEnding is invalid on user data. Current LineEnding setting is LF appeared first on Just Another Dang Blog.

• Use the official Google API client library for authentication and API calls.
• Understand OAuth 2.0 authentication.
• Set up Google Cloud Console for API access, credentials, and OAuth consent.
• Build a Next.js app from login to authorization using cookies.
• Finally, we’ll make a Google Drive API call to list the first 10 documents in your Google Drive.

Ready? Let’s get started!

Step 1: Set Up Google Cloud Console

Head over to console.cloud.google.com.Create a New Project.Under API & Services:

• Click on Enable APIs and Services.
• Enable the Google Drive API.

Next, Create Credentials:

• Select User Data as the type.
• Choose OAuth Client ID.
• Set Web Application as the app type.
• In Authorized JavaScript Origins, add:
  • http://localhost:3000
  • http://localhost
• For Authorized Redirect URIs, add:
  • http://localhost:3000
  • http://localhost:3000/api/oauth2/callback

Step 2: Install Dependencies

npm install googleapis
npx shadcn@latest init -d
npx shadcn@latest add button

Step 3: Set Up Your .env File

GOOGLE_CLIENT_ID=your-client-id
GOOGLE_CLIENT_SECRET=your-client-secret
GOOGLE_REDIRECT_URI=http://localhost:3000/api/oauth2/callback

These values are required to authenticate users via Google OAuth.

Step 4: Building the OAuth2 Flow

Create a global oauth2client utility that’s accessible throughout your app:

import { google } from 'googleapis';
const oauth2Client = new google.auth.OAuth2(
  process.env.GOOGLE_CLIENT_ID,
  process.env.GOOGLE_CLIENT_SECRET,
  process.env.GOOGLE_REDIRECT_URI
);

Create a login button on your Page.tsx and get the authorizationURL by passing the access_type and scope

/app/Page.tsx

import { Button } from "@/components/ui/button";
import oauth2Client from "./utils/google-auth";
import Link from "next/link";

export default function Home() {
  const SCOPE = ["https://www.googleapis.com/auth/drive.metadata.readonly"];

  const authorizationURL = oauth2Client.generateAuthUrl({
    access_type: "offline",
    scope: SCOPE,
  });

  return (
    <div className="grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 pb-20 gap-16 sm:p-20 font-[family-name:var(--font-geist-sans)]">
      <Link href={authorizationURL}>
        <Button>Login To Google</Button>
      </Link>
    </div>
  );
}

Step 5: Handle the Callback

Next, let’s handle that callback and exchange the authorization code for an access token.

• Create the API route for your OAuth2 callback: /app/api/oauth2/callback/route.ts
• Save the access token in a cookie so it can be used for subsequent API calls.
• Redirect to the dashboard

import { NextResponse } from 'next/server';
import { cookies } from 'next/headers';
import oauth2Client from '@/app/utils/google-auth';

export async function GET(req: Request) {
    const { searchParams } = new URL(req.url);
    const code = searchParams.get('code');
    const error = searchParams.get('error');

    if (error) {
        return NextResponse.json({ error: 'Google OAuth Error: ' + error });
      }
    
    if (!code) {
        return NextResponse.json({ error: 'Authorization code not found' });
    }

    try {
        const { tokens } = await oauth2Client.getToken(code);
        cookies().set({
            name: 'google_access_token',
            value: tokens.access_token || '',  // the access token
            httpOnly: true,  // for security, the cookie is accessible only by the server
            secure: process.env.NODE_ENV === 'production',  // send cookie over HTTPS only in production
            path: '/',  // cookie is available on every route
            maxAge: 60 * 60 * 24 * 7,  // 1 week
        });

        return NextResponse.redirect(new URL("/dashboard", req.url));
    } catch (error) {

        return NextResponse.json({ error: 'Google OAuth Error failed to exchange code: ' + error });
    }
}

Step 6: Call Google APIs (Google Drive Example)

Now that the user is authenticated, we can use the OAuth2 client to make API calls. For example, let’s fetch the first 10 documents from Google Drive:

• Call the Google Drive API: /app/dashboard/Page.tsx

import oauth2Client from "../utils/google-auth";
import { cookies } from "next/headers";
import { google } from "googleapis";

export default async function Page() {
  const cookieStore = cookies();
  const accessToken = cookieStore.get("google_access_token")?.value;
  oauth2Client.setCredentials({ access_token: accessToken });
  let files;

  const drive = google.drive("v3");

  try {
    const result = await drive.files.list({
      auth: oauth2Client,
      pageSize: 10,
      fields: "nextPageToken, files(id, name)",
    });
    files = result.data.files;
  } catch (error) {
    console.log(error);
    return (
      <div className="justify-center w-full flex text-center pt-10 flex-col items-center">
        Something went wrong! Please login again!
      </div>
    );
  }

  return (
    <div className="justify-center w-full flex text-center pt-10 flex-col items-center">
      <h1 className="text-lg font-bold">Google Drive Files</h1>
      <ul>
        {files?.map((file) => (
          <li key={file.id}>{file.name}</li>
        ))}
      </ul>
    </div>
  );
}

This code lists the first 10 files in your Google Drive, provided the OAuth2 client has valid credentials.

Conclusion

To wrap it up, here’s what we covered:

1. Setting up a Google Cloud project and enabling the Drive API.
2. Implementing OAuth2 in your Next.js app, including the login flow and handling callbacks.
3. Storing the access token in cookies to maintain the session.
4. Calling Google APIs, like Google Drive, using the authenticated OAuth2 client.

Now you have a fully functional app that integrates with Google APIs, allowing you to explore other Google services in a similar fashion. Enjoy building!

The post How to Integrate Google APIs with a Next.js App (OAuth 2.0 Guide) appeared first on Just Another Dang Blog.

What is jsforce?

jsforce (formerly known as Node-Salesforce) is a powerful JavaScript library that allows you to interact with Salesforce’s API. It works both in the browser and with Node.js, making it versatile for various scenarios. When combined with Next.js, a full-stack React framework, you can create a seamless integration between Salesforce and your app’s frontend or backend.

In this tutorial, we’ll cover:

1. Building a Basic Next.js App to Fetch Salesforce Accounts: We’ll retrieve a list of accounts from your Salesforce organization using the Salesforce REST API.
2. Exploring jsforce Authentication: We’ll walk through different authentication methods, from basic to more secure OAuth2 flows, and troubleshoot common issues.

Step 1: Setting Up a Basic Next.js App

First, let’s create a simple Next.js app to get the accounts from your Salesforce organization. We’ll be using the jsforce library to handle the API communication. Here’s how to get started:

1. Initialize a Next.js project:
   • npx create-next-app@latest salesforce-nextjs
   • cd salesforce-nextjs
   • npm install jsforce
2. create a new file called .env.local on the root project
3. Create different pages and api routes to show different methods how Next.js connects to Salesforce using jsforce and retrieves the account data.

//.env.local sample file
USERNAME=
PASSWORD=
CLIENT_ID=
CLIENT_SECRET=
REDIRECT_URI=

//sample pages
app/username-password/page.tsx
app/username-password-flow/page.tsx
app/webserver-flow/page.tsx
app/dashboard/page.tsx

//sample api routes
api/oauth2/auth/route.ts
api/oauth2/callback/route.ts

Step 2: Understanding jsforce Authentication Methods

There are multiple ways to authenticate with Salesforce using jsforce, ranging from less secure to more secure approaches:

Username-Password SOAP API Login

This method is simple but less secure. It involves providing your Salesforce username and password along with a security token to authenticate. While useful for quick testing, it is not recommended for production use.

import jsforce from "jsforce";

export default async function Page() {
  const conn = new jsforce.Connection({
    // you can change loginUrl to connect to sandbox or prerelease env.
    // loginUrl : 'https://test.salesforce.com'
  });

  await conn.login(process.env.USERNAME!, process.env.PASSWORD!);

  const result = await conn.query("SELECT Id, Name FROM Account LIMIT 15");

  return (
    <div>
      Username Password Page
      <ul className="list-disc list-inside">
        {result.records.map((record) => (
          <li key={record.Id}>{record.Name}</li>
        ))}
      </ul>
    </div>
  );
}

OAuth2 Authentication

For production applications, OAuth2 is the more secure and preferred way to authenticate. It provides various flows based on your specific use case.

1. OAuth2 Username-Password Flow: This flow allows you to log in using the user’s Salesforce credentials, but it is less secure because it requires storing the username and password.
2. OAuth2 Web Server Flow: This is a more secure option where you redirect the user to Salesforce to log in. Once authenticated, Salesforce redirects the user back to your app with a session token, which you can use to access the API.

//username-password flow/page.tsx
import jsforce from "jsforce";

export default async function Page() {
  const conn = new jsforce.Connection({
    oauth2: {
      // you can change loginUrl to connect to sandbox or prerelease env.
      // loginUrl : 'https://test.salesforce.com',
      clientId: process.env.CLIENT_ID,
      clientSecret: process.env.CLIENT_SECRET,
      redirectUri: process.env.REDIRECT_URI,
    },
  });

  await conn.login(process.env.USERNAME!, process.env.PASSWORD!);

  const result = await conn.query("SELECT Id, Name FROM Account LIMIT 15");

  return (
    <div>
      Username Password Page
      <ul className="list-disc list-inside">
        {result.records.map((record) => (
          <li key={record.Id}>{record.Name}</li>
        ))}
      </ul>
    </div>
  );
}

//webserver-flow/page.tsx
"use client";
import React from "react";

export default function Page() {
  const handleLogin = () => {
    window.location.href = "/api/oauth2/auth";
  };
  return (
    <div>
      <button onClick={handleLogin}>Login to Salesforce</button>
    </div>
  );
}

//api/oauth2/auth/route.ts
import { OAuth2 } from 'jsforce';
import { NextResponse } from 'next/server';

const oauth2 = new OAuth2({
    // you can change loginUrl to connect to sandbox or prerelease env.
    // loginUrl : 'https://test.salesforce.com',
    clientId: process.env.CLIENT_ID,
      clientSecret: process.env.CLIENT_SECRET,
      redirectUri: process.env.REDIRECT_URI,
  });

  export async function GET() {
    const authUrl = oauth2.getAuthorizationUrl({scope: 'api id web'})

    return NextResponse.redirect(authUrl);
  }

• You need to create a “Connected App” in Salesforce to set up this flow.
• Once the user is authenticated, save the session ID in a cookie. Your app can then read this session ID from the cookie and use it to make API requests to Salesforce.

Step 3: Setting Up a Connected App in Salesforce

1. Log in to Salesforce.
2. Go to Setup and search for “App Manager.”
3. Click New Connected App and fill in the required fields, such as callback URL, OAuth scopes, etc.
4. Ensure you enable OAuth settings and specify the correct callback URL (e.g., https://yourapp.com/api/callback).

Handling OAuth2 Web Server Flow in Next.js

Here’s how to handle the callback from Salesforce and manage session cookies in Next.js:

//app/api/oauth2/callback/route.ts
import {OAuth2, Connection} from 'jsforce';
import { NextResponse } from 'next/server';
import { cookies } from 'next/headers';

const oauth2 = new OAuth2({
    clientId: process.env.CLIENT_ID,
    clientSecret: process.env.CLIENT_SECRET,
    redirectUri: process.env.REDIRECT_URI,
  });

  export async function GET(req: Request) {
    const { searchParams } = new URL(req.url);
    const code = searchParams.get('code');
    const error = searchParams.get('error');

    if (error) {
      return NextResponse.json({ error: 'Salesforce Oauth Error:' + error});
    }

    if (!code) {
      return NextResponse.json({ error: 'No Authorization code found'});
    }

    try {
        const conn = new Connection({ oauth2 });
        

        await conn.authorize(code);

        // Set the access token in an HTTP-only, secure cookie
        cookies().set({
        name: 'salesforce_access_token',
        value: conn.accessToken || '',  // the access token
        httpOnly: true,  // for security, the cookie is accessible only by the server
        secure: process.env.NODE_ENV === 'production',  // send cookie over HTTPS only in production
        path: '/',  // cookie is available on every route
        maxAge: 60 * 60 * 24 * 7,  // 1 week
     });
      
          // Optionally, you can store the instance URL in a cookie if needed
          cookies().set({
              name: 'salesforce_instance_url',
              value: conn.instanceUrl || '',
              httpOnly: true,
              secure: process.env.NODE_ENV === 'production',
              path: '/',
              maxAge: 60 * 60 * 24 * 7,  // 1 week
          });

        return NextResponse.redirect(new URL('/dashboard', req.url));
    } catch(err) {
        return NextResponse.json({ error: 'Salesforce Oauth Error:' + err});
    }
  }

//app/dashboard/page.tsx
import jsforce from "jsforce";
import { cookies } from "next/headers";

export default async function page() {
  const cookieStore = cookies();
  const accessToken = cookieStore.get("salesforce_access_token")?.value;
  const instanceUrl = cookieStore.get("salesforce_instance_url")?.value;
  let result;
  try {
    const conn = new jsforce.Connection({
      instanceUrl: instanceUrl,
      accessToken: accessToken,
    });

    result = await conn.query("SELECT Id, Name FROM Account LIMIT 15");
  } catch (err) {
    console.log(err);
    return <div>Failed to fetch data from Salesforce</div>;
  }
  return (
    <div>
      Web server flow
      <ul className="list-disc list-inside">
        {result.records.map((record) => (
          <li key={record.Id}>{record.Name}</li>
        ))}
      </ul>
    </div>
  );
}

In this code, after Salesforce authenticates the user, the session token is stored in a cookie for future API calls.

Troubleshooting Common Issues

While integrating Salesforce with a Next.js app, you might run into some common authentication issues:

• Invalid Grant or Authentication Failure: "error": "Failed to authorize with Salesforce: invalid_grant: authentication failure" Solution: Ensure that your Salesforce security settings (e.g., IP restrictions) are relaxed for testing purposes.
• OAuth Approval Error:
  json "error": "OAUTH_APPROVAL_ERROR_GENERIC"
  Solution: Double-check your OAuth scopes and make sure the app has the correct permissions in Salesforce.

Wrapping Up

Integrating Salesforce with a Next.js app using jsforce can unlock powerful possibilities for accessing and managing Salesforce data in your web applications. While the authentication setup may seem complex at first, the OAuth2 web server flow ensures a secure and scalable integration for real-world applications.

For a deeper dive into Salesforce authentication or if you’re encountering further issues, check out my previous post on using Salesforce with Postman.

Watch the video

Feel free to leave a comment or reach out if you have any questions. Happy coding!

The post How to Integrate Salesforce with a Next.js App Using jsforce appeared first on Just Another Dang Blog.

In this blog post, we will walk through how to integrate Salesforce with Postman using a connected app. Salesforce provides a secure way for third-party applications to access its resources through a REST API. To achieve this, you need to authorize the app using OAuth 2.0 authorization flows. We’ll cover different flows like Authorization Code with PKCE, Username-Password, Client Credentials, and Web Server Flow, as well as how to troubleshoot some common errors along the way.

Prerequisites

Before we dive into the details, ensure the following:

• You have Postman installed.
• You have access to a Salesforce organization (either a sandbox or developer edition).

Overview

When building a web application that needs to access Salesforce resources, the client app must be authorized to do so securely. This is typically done using OAuth 2.0 and a connected app. Here’s how the general flow works:

1. Authorization Requirement: The client application (e.g., your web app) wants to access Salesforce resources like data or services.
2. Authorization Process: In order to access these resources, the client needs authorization.
3. Authentication Server Role: Salesforce delegates the responsibility of authenticating and authorizing the client to its Authorization Server.
4. Token Usage:
   • Once successfully authenticated, the client app receives an access token.
   • The app can use this access token to access Salesforce resources.
   • Additionally, the client can request a new access token using a refresh token, if needed.

Step-by-Step Guide

1. Setting Up a Connected App

To begin, we need to create a connected app in Salesforce. This is essential for any external application to securely integrate with Salesforce using OAuth 2.0. The connected app provides the client ID, secret, and the necessary configuration to authenticate.

2. Using OAuth 2.0 Flows in Postman

Once the connected app is set up, we will use Postman to try out different OAuth 2.0 authorization flows. These flows provide various ways to authenticate and authorize access. Let’s walk through the key flows:

• Authorization Code Flow
  This is a standard OAuth 2.0 flow for web apps. It requires user interaction for granting access. In Postman, you’ll exchange an authorization code for an access token.
• Authorization Code with PKCE
  PKCE (Proof Key for Code Exchange) is an extension to OAuth 2.0 that adds an extra layer of security by using a dynamically generated secret. This is often used in public clients (like mobile apps). You’ll need a callback URL in Salesforce to complete this flow.
• Username-Password Flow
  This flow is used in scenarios where you trust the client app with the user’s credentials. It’s considered less secure and is only recommended for trusted applications.
• Client Credentials Flow
  This flow is ideal for machine-to-machine authentication where there’s no user involvement. It uses only the client ID and secret.
• Web Server Flow
  This flow allows your application to obtain an access token through the back-end server rather than exposing it to the front-end.

Troubleshooting Common Errors

When working with OAuth flows, you may encounter errors. Here’s one common error and how to troubleshoot it:

Error: invalid_grant, Description: request not supported on this domain

Solution:
This error typically means that the domain you are using in Postman or Salesforce isn’t correctly set up for OAuth. Ensure the callback URL matches what is configured in your Salesforce connected app, and check whether the domain supports OAuth requests.

Watch full breakdown in this video

Conclusion

Using Postman to integrate with Salesforce can streamline your API development process. With a properly configured connected app and an understanding of different OAuth 2.0 flows, you’ll be able to authenticate and access Salesforce resources securely. Always make sure to use the right flow based on your application’s needs and handle errors gracefully.

That’s it for this tutorial! I hope you now have a solid understanding of how to set up and use Postman with Salesforce through a connected app. If you run into any challenges or have more questions, feel free to drop a comment below.

The post Step-by-Step Guide: Integrating Salesforce with Postman Using OAuth 2.0 and Connected Apps appeared first on Just Another Dang Blog.

pauloorquillo@Paulos-MBP VersionControl % sf version
(node:34452) [DEP0040] DeprecationWarning: The `punycode` module is deprecated. Please use a userland alternative instead.
(Use `node --trace-deprecation ...` to show where the warning was created)
@salesforce/cli/2.24.4 darwin-arm64 node-v21.5.0

Update: This issue seems to have been fixed with node-v21.6.0 and higher. Make sure you update to the latest node version. If you are still having the issue check the solution below.

You can ignore the warning if you want. But to fix this you would need to downgrade your node version installed via homebrew. Open up the terminal and do the following commands and reading through my comments.

#uninstall the salesforce cli for a clean install later
npm uninstall @salesforce/cli --global

#list all apps to make sure you have node installed
brew list

#uninstall that version of node
brew uninstall node

#install older version of node
brew install node@20

#update the link in homebrew to look into this latest version
brew link —overwrite node@20 

#check node version
node -v

#finally install the salesforce cli again
npm install @salesforce/cli --global

#check that no warnings are thrown by running this command
sf version

There you go, hope you like this tip and found it useful.

The post How to install the latest @salesforce/cli with node20 using Homebrew. appeared first on Just Another Dang Blog.