• contact@writeaboutcoding.com

How to Create a Simple Blog Rest API

By 16 min read

How to Create a Simple Blog Rest API with Flask

Welcome to our guide on creating a simple blog REST API with Flask!

If you’re looking to build a blog, you know a lot goes into it.

As a developer, You need to design a frontend, create a database, and implement various features like comments and likes. But what if you want to focus on the backend and make it easy for other developers to build their frontends on your API?

That’s where REST APIs come in.

REST (Representational State Transfer) is an architectural style for building web services that communicate over the HTTP protocol. A REST API exposes resources (like blog posts or user profiles) as URLs. It allows clients (like a frontend app or another server) to perform CRUD (Create, Read, Update, Delete) operations on those resources using HTTP methods like GET, POST, PUT, and DELETE.

Learn more about REST APIs design and best practices.

Flask is a lightweight and flexible web framework for Python that makes it easy to build REST APIs. It has a simple and intuitive syntax and many useful libraries and tools for handling web requests, working with databases, and more.

This guide will walk you through the steps for creating a simple blog REST API with Flask.
By the end, you’ll have a fully functional API that can handle blog post creation, retrieval, updating, and deletion, user authentication and authorization.

Let’s get started!

Now that you’re excited to build a blog REST API with Flask let’s start by setting up your Flask environment. Here are the steps:

Setting Up Your Flask Environment

Now that you’re excited to build a blog REST API with Flask, let’s start by setting up your Flask environment. Here are the steps:

Installing Flask and Other Necessary Packages

First, you need to install Flask and other packages that you’ll need for your blog API. You can use pip or pip3, the package installer for Python, to install Flask and other packages.

For this project, we’re installing the following:

  • Flask
  • Flask-RESTful (a Flask extension for building REST APIs)
  • Flask_sqlalchemy

pip install Flask
pip install Flask-RESTful
pip install flask_sqlalchemy

Creating a Virtual Environment

It’s always a good idea to create a virtual environment for your Flask app, to avoid conflicts with other Python packages. You can use venv, the built-in virtual environment module in Python, to create a new virtual environment.

Here, we’re creating a new virtual environment called simple_blog, and activating it with the source command. You’ll see that your command prompt changes to indicate that you’re now working in the virtual environment.


python -m venv simple_blog
source simple_blog/bin/activate

Creating a Flask App

Now that you’ve set up your virtual environment, you can create a new Flask app. Here’s a simple example app:

  1. Import the Flask class.
  2. Then create a new Flask app instance. 
  3. Define a route for the root URL (/).
  4. Define a function to handle that route (hello_world). 

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello_world():
    return "Hello, World!"

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

The if __name__ == “__main__” block is used to run the app in debug mode when the script is executed directly (as opposed to being imported as a module).

To run the app, save the above code as app.py in your project directory and run:

Visit http://localhost:5000 in your web browser, and you should see “Hello, World!” displayed.

Designing Your API

Now that you have your Flask environment set up, it’s time to start designing your API. Here are three easy steps to consider:

  • Decide on your API Endpoint
  • Choose HTTP Methods for each endpoints
  • Design your API Database Schema

Deciding on Endpoints for Your API

Before you start coding, you need to decide on your API’s endpoints (URLs). Doing this will help you properly plan your projects and track which API you have completed.

Here are some examples:

  • /posts: Retrieve a list of all blog posts
  • /posts/<int:id>: Retrieve a specific blog post by ID
  • /posts/new: Create a new blog post
  • /posts/<int:id>/edit: Update an existing blog post by ID
  • /posts/<int:id>/delete: Delete an existing blog post by ID
  • /users: Retrieve a list of all users
  • /users/<int:id>: Retrieve a specific user by ID
  • /users/new: Create a new user
  • /users/logout: Log out a user
  • /users/login: Log in as a user

Choosing HTTP Methods for Each Endpoint

Next, you must decide which HTTP methods to use for each endpoint. Here are some standard methods:

GET: Retrieve a resource or a list of resources

POST: Create a new resource

PUT: Update an existing resource

DELETE: Delete an existing resource

For example, you would use GET to retrieve a list of blog posts (/posts) or a specific blog post (/posts/<int:id>), POST to create a new blog post (/posts/new), PUT to update an existing blog post (/posts/<int:id>/edit), and DELETE to delete an existing blog post (/posts/<int:id>/delete).

Designing Your API Schema

Finally, you need to design your API schema. This includes the data models for your blog posts and users, as well as the API endpoints and methods for CRUD operations on those models.

Here’s the database schema for our blog project.

Create a file models.py.


""" Module for the blog schema"""
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime
db = SQLAlchemy()

class User(db.Model):
    """User model that creates a user table with colums id, username and password. """

    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(50), nullable=False)
    password = db.Column(db.String(50), nullable=False)
  
class Post(db.Model):

    """Post models with columns id, title,content, author_id and data"""

    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)
    author_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
    created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow())
    author = db.relationship("User", backref=db.backref("posts", lazy=True))

    def to_dict(self):
      """ returns a dictionary for the model object"""
      return {
          "id": self.id,
          "title": self.title,
          "content": self.content,
          "author": self.author.username,
          "created_at": self.created_at.isoformat()
      }

Here, we defined two models (User and Post) using SQLAlchemy. SQLAlchemy is a popular Python library for working with databases. We also defined a one-to-many relationship between users and posts. The author_id foreign key in the Post model and the posts relationship in the User model.

We’ve also defined a to_dict method on the Post model, which returns a dictionary representation of a post that can be serialized as JSON and returned by our API.

Implementing Your API

Now that we have designed our API, it’s time to implement it using Flask. Here are the steps:

Setting up the API Routes

First, we need to set up the API routes in our Flask app. Then create a file app.py in our project root directory.

Import your db, Post and User from the models.py we created in the previous section. 


from flask import Flask, jsonify, request
from models import db, Post, User

The lines of code above import the required Flask framework and necessary dependencies, as well as the database models for the application. Import “jsonify” to convert the responses to JSON format. Also, the “request” handles HTTP requests in

The next step is to create a Flask application instance with the name of the current module.


app = Flask(__name__)

Set the URI for the SQLite database where the blog data will be stored.


app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///blog.db"

Disable the SQLAlchemy modification tracker since it can cause performance issues in some cases.


app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False

Initialize the database with the Flask application instance.


db.init_app(app)

Create a decorator `@app.before_first_request` that specifies a function to be run before the first request to the application is processed. The create_all function creates all the necessary database tables if they don’t already exist.


@app.before_first_request
def create_tables():
    db.create_all()

Lets define an `/posts` endpoint that returns a JSON response of all the blog posts. It uses the Post model to query the database for all the posts. You can use a list comprehension to convert each post to a dictionary representation using the to_dict() method.


@app.route('/posts', methods=['GET'])
def get_posts():
  posts = Post.query.all()
  return jsonify([post.to_dict() for post in posts])

Let’s create the /posts/<id> endpoint that returns a JSON response of a specific blog post based on its id.

The get_or_404() method to query the database for the post with the specified id, and if it doesn’t exist, it returns a 404 error. It then converts the post to a dictionary representation using the to_dict() method and returns it as a JSON response.


@app.route('/posts/<int:id>', methods=['GET'])
def get_post(id):
  post = Post.query.get_or_404(id)
  return jsonify(post.to_dict())

The next endpoint we will create is `/post/new` that allows the creation of a new blog post via a POST request.

We expect a JSON data with the post title, content, and author_id fields, which it uses to create a new Post object. It then adds the post to the database session and commits the changes. Finally, it returns the newly created post as a JSON response with a 201 status code.


@app.route('/post/new', methods=['POST'])
def create_post():
  data = request.json
  post = Post(title=data['title'], content=data["content"], author_id=data["author_id"])
  db.session.add(post)
  db.session.commit()
  return jsonify(post.to_dict()), 201

Another endpoint on our list is the /posts/<id>/edit that allows the editing of a specific blog post via a PUT request. You can expect a JSON data with the title and content fields that will be used to update the post. You can use the get_or_404() method to query the database for the post with the specified id, and if it doesn’t exist, it returns a 404 error.

If the post exists, you updates the title and content fields with the new data and commits the changes to the database. Finally, it returns the updated post as a JSON response.


@app.route("/posts/<int:id>/edit", methods=["PUT"])
def update_post(id):
    data = request.json
    post = Post.query.get_or_404(id)
    post.title = data.get("title", post.title)
    post.content = data.get("content", post.content)
    db.session.commit()
    return jsonify(post.to_dict())

The last endpoint is /post/<id>/delete that allows the deletion of a specific blog post via a DELETE request. We will use the get_or_404() method to query the database for the post with the specified id, and if it doesn’t exist, it returns a 404 error.

If the post exists, it deletes it from the database session and commits the changes. Finally, it returns a 204 status code indicating that the request was successful but there is no content to return.


@app.route("/post/<int:id>/delete", methods=['DELETE'])
def delete_post(id):
  post = Post.get_or_404(id)
  db.session.delete(post)
  db.session.commit()
  return "204"

Finally, we can execute script is run as the main program. We create a new User object with a username of 'test' and a password of '12345'. It then adds the user to the database session and commits the changes. Finally, it starts the Flask development server with debugging enabled.

if __name__ == "__main__":
  user = User(username='test', password='12345')
  with app.app_context():
    db.session.add(user)
    db.session.commit()
  app.run(debug=True)

Here is the full code:

from flask import Flask, jsonify, request
from models import db, Post, User

app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///blog.db"
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
db.init_app(app)

@app.before_first_request
def create_tables():
    db.create_all()

@app.route('/posts', methods=['GET'])
def get_posts():
  posts = Post.query.all()
  return jsonify([post.to_dict() for post in posts])

@app.route('/posts/<int:id>', methods=['GET'])
def get_post(id):
  post = Post.query.get_or_404(id)
  return jsonify(post.to_dict())

@app.route('/post/new', methods=['POST'])
def create_post():
  data = request.json
  post = Post(title=data['title'], content=data["content"], author_id=data["author_id"])
  db.session.add(post)
  db.session.commit()
  return jsonify(post.to_dict()), 201

@app.route("/posts/<int:id>/edit", methods=["PUT"])
def update_post(id):
    data = request.json
    post = Post.query.get_or_404(id)
    post.title = data.get("title", post.title)
    post.content = data.get("content", post.content)
    db.session.commit()
    return jsonify(post.to_dict())

@app.route("/post/<int:id>/delete", methods=['DELETE'])
def delete_post(id):
  post = Post.get_or_404(id)
  db.session.delete(post)
  db.session.commit()
  return "204"

if __name__ == "__main__":
  user = User(username='test', password='12345')
  with app.app_context():
    db.session.add(user)
    db.session.commit()
  app.run(debug=True)

Testing the API

Once you have implemented your API, you should test it thoroughly to make sure it works as expected. You can use a tool like Postman or curl to send HTTP requests to your API endpoints and verify that they return the expected responses.

For example, you could use the following curl commands to test the get_posts and create_post endpoints:

# Get all posts
$ curl http://localhost:5000/posts

# Create a new post
$ curl -X POST -H "Content-Type: application/json" -d '{"title": "My New Post", "content": "Lorem ipsum dolor sit amet", "author_id": 1}' http://localhost:5000/posts/new

Conclusion

Congratulations, you have successfully created a simple blog REST API with Flask! Here’s a quick recap of the steps we covered:

  1. Designed the API routes and endpoints.
  2. Set up the Flask app and the database.
  3. Created the models for the API.
  4. Implemented the API routes in the Flask app.
  5. Tested the API using a tool like Postman or curl.
  6. Deployed the API to a server or cloud platform like Heroku or AWS.

Here are a few tips for extending and improving your API:

  • Use authentication and authorization to secure your API.
  • Add validation to your endpoints to ensure that data is being passed in the correct format.
  • Use pagination to limit the amount of data returned by endpoints that return multiple records.
  • Add caching to improve performance.

If you want to learn more about Flask and REST API development, here are some resources you can check out:

That’s it for this tutorial! I hope you found it helpful, and happy coding!

FAQ

What is Flask?

Flask is a lightweight web application framework written in Python. It is designed to be simple and easy to use, making it a popular choice for building web applications and APIs.

What is a REST API?

A REST API (Representational State Transfer Application Programming Interface) is a way for web applications to communicate with each other using HTTP requests. It allows clients to request and receive data from a server in a standardized way, using a set of rules and conventions.

Why should I use Flask to build a REST API?

Flask is a great choice for building REST APIs because it is lightweight and flexible, allowing you to quickly build and deploy APIs with minimal setup. It is also highly customizable, making it easy to add new features and functionality as your API grows.

What is SQLAlchemy?

SQLAlchemy is a Python library for working with relational databases. It provides an easy-to-use interface for performing common database operations, such as querying, inserting, and updating data. It also supports a variety of different database backends, including SQLite, MySQL, and PostgreSQL.

How can I deploy my Flask API to a production server?

There are several options for deploying Flask applications to production servers. One popular choice is to use a cloud platform like Heroku or AWS, which provide easy-to-use deployment tools and scalable infrastructure. Another option is to set up your own server using a tool like Docker or Kubernetes.

How can I test my Flask API?

You can test your Flask API using a tool like Postman or curl. These tools allow you to send HTTP requests to your API endpoints and view the responses. You can also write automated tests using a testing framework like pytest, which allows you to test your endpoints in a more structured and repeatable way.

Can I use Flask to build a real-world web application?

Absolutely! Flask is a great choice for building web applications of all sizes, from small personal projects to large-scale enterprise applications. It is highly customizable and flexible, making it easy to add new features and functionality as your application grows. Additionally, its large and supportive community means that there are plenty of resources available to help you get started and solve any problems you may encounter along the way.

How do I create a simple REST API using Flask?

A: To create a simple REST API using Flask, you’ll need to set up your Flask app and define your API routes and endpoints. You’ll also need to create models for your API and implement the routes in your Flask app. You can test your API using a tool like Postman or curl, and deploy it to a server or cloud platform like Heroku or AWS. This tutorial covers all of these steps in detail.

Can you build a blog with Flask?

A: Yes, you can build a blog with Flask. Flask is a powerful web framework that allows you to build complex web applications, including blogs. Moreover, we used Flask to create a simple blog REST API in this tutorial.

Can you use REST API with Flask?

A: Yes, Flask is a great framework for building REST APIs. Flask has built-in support for RESTful routing and makes it easy to define and implement API endpoints. Also, it also allows you to use a variety of extensions and libraries to further enhance your API.

Related Posts