Hi Tip-Sheeters,

Lots of content to share this week, so let's jump in and get started!

When Your API Needs an Endpoint

When you're creating technical prototypes and side projects that include APIs, you may be performing your development on a local machine. But once the API is stable, you'll quickly want to be able to access it on the public Internet.

For example, you may want to:

• Call it with an agent, generative AI app, or various other ways​
• Call it with an ETL tool or data pipeline
• ​Use it in a data app using Streamlit or Gradio
• Share an ML model with it
• Expose it to a webhook

These are just a few ways you might want to use your API with some web-connected apps.

In this newsletter, I'll share a couple of convenient ways to get an HTTPS endpoint for your API.

1. Use GitHub Codespaces

If you've followed my newsletter long, you know that I do all of my side projects these days using GitHub Codespaces. Codespaces provide a Linux container running VS Code connected to your GitHub repo. They're a fantastic way to keep your code environments clean.

And a major bonus for API development is that you can expose your API endpoint on the public Internet. Here's how you do it using a FastAPI API:

1. Spin up a Codespace and launch your API. For instance, with the command `fastapi run main.py'.
2. Codespaces will display this dialog, click "Make Public"

3. On the PORTS tab, you should see that your API is running with visibility of Public.

4. Hover your mouse over the forwarded address and click "Open in Browser". Copy the address from the browser bar.

5. To verify the URL is public, copy it and open it in a separate browser (e.g., if you're running Codespaces in Chrome, open the URL in Edge or Safari.)

6. The first time you visit the API endpoint, you should see this warning:

7. Click continue, and you should see the API in your browser. In this case, my API has a health check message at the root API endpoint:

2. Use proxy software like Ngrok

If you're not running your API in Codespaces, you can still get a public URL using a proxy service like Ngrok. Ngrok uses software that you run in your local environment to connect to the public Internet through the ngrok service. This gives an Internet-facing HTTPS URL that is routed to your local environment.

Here are the general steps to get this running:

1. ​Sign up for a free account with ngrok and save your personal authtoken.
2. Install the software in your local environment using these instructions and configure your authtoken.
3. Launch your API in your local environment, and note the local address and port your API is running on (e.g., http://localhost:8080).
4. In another terminal window, run the `ngrok http` command pointing to your local API, such as `ngrok http http://localhost:8080`.
5. If all goes well, the ngrok terminal screen will run, showing the public URL of your API with two key pieces of information: "Web interface" will show the local web address of the ngrok admin app. "Forwarding" will show the public URL where your API is available.
6. Open the local web app from the "Web interface" address, and you should see something that looks like the following:

7. Click on the URL on this web app (or go direcly from the "Forwarding" address on the terminal screen), and you should see this warning:

8. Click "Visit Site" and you should see the root page of your API.

Those are two ways to get a public URL for your API. If you have a few more recommendations, please pass them along!

Useful Links this Week

Here are a few useful links around APIs and AI from recent weeks:

​How I'm Currently Upskilling as a Senior Data Scientist in Tech (2025 Edition) - This is a fantastic post from Andres Vourakis, who publishes the To Be A Data Scientist newsletter. Andres does a fantastic job explaining his own personal technical development plan for this year -- everyone needs one of these!

​Comparing 7 AI Agent-to-API Standards - Since the world of Agentic AI is so new, a variety of standards are competing for attention. This article gives a summary that includes some of the more familiar ones, like MCP and A2A, as well as some that I hadn't heard of like LangChain's Agent-Protocol.

​MCP Authorization With Dynamic Client Registration - Speaking of MCP, Christian Posta has been putting out some really detailed MCP content lately. This one explains a key part of the proposed authentication for the MCP standard, Dynamic Client Registration. Good deep diver here.

​Building Great SDKs - Deep dive on SDK development from the Pragmatic Engineer blog. Great stuff!

That's all for this week!

Keep coding,

Ryan Day

👉 https://tips.handsonapibook.com/ -- no spam, just a short email every week.