Summary of "Build a REST API in Python | API Crash Course"

Concise summary

The video (Code with Josh) explains what an API and a REST API are, covers core HTTP concepts (URIs, CRUD, JSON, status codes), and walks step-by-step through building a REST API in Python using Flask and Flask‑SQLAlchemy. It also shows how to test the API using Postman.

Main concepts and lessons

What an API is An application programming interface — the middle layer that allows a client (front end) to request data from a server (back end) and receive responses.
REST (Representational State Transfer) APIs expose resources via URIs (endpoints) and use HTTP methods to manipulate them.
URIs Each resource is accessible via a unique URI, for example: /destinations and /destinations/<id>.
HTTP methods / CRUD mapping
- POST = Create
- GET = Read
- PUT = Update
- DELETE = Delete
JSON The common payload format for API requests/responses. It resembles a Python dict (key/value pairs).
HTTP status codes
- 200 OK — general success
- 201 Created — resource created
- 400 Bad Request — client request error
- 404 Not Found — resource not found
- 500 Server Error — server-side error
ORMs (SQLAlchemy) Let you use Python classes/objects instead of writing SQL directly.

Detailed step‑by‑step methodology to build the REST API

Create and activate a virtual environment
- Create: python3 -m venv <env_name> # example python3 -m venv APIEnv
- Activate (Unix/macOS): source APIEnv/bin/activate
- Activate (Windows, example): APIEnv\Scripts\activate
Install dependencies pip install flask flask-sqlalchemy Optionally export dependencies: pip3 freeze > requirements.txt
Basic Flask app setup
- Imports: python from flask import Flask, jsonify, request from flask_sqlalchemy import SQLAlchemy
- Create app: python app = Flask(__name__)
- Configure database URI (example uses SQLite): python app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///travel.db'
- Create ORM instance: python db = SQLAlchemy(app)
- Run guard: python if __name__ == '__main__': app.run(debug=True)
Define the database model (example: Destination) ```python class Destination(db.Model): id = db.Column(db.Integer, primary_key=True) destination = db.Column(db.String(50), nullable=False) country = db.Column(db.String(50), nullable=False) rating = db.Column(db.Float, nullable=False)

def to_dict(self): return { ‘id’: self.id, ‘destination’: self.destination, ‘country’: self.country, ‘rating’: self.rating } `` Theto_dict` method simplifies converting model instances to JSON-friendly dicts.
Create the database file Use the Flask app context to create tables: python with app.app_context(): db.create_all() This generates the SQLite file (for example, instance/travel.db).
Implement routes (endpoints) — CRUD
- Home route: python @app.route('/') def home(): return jsonify({'message': 'welcome to the travel API'})
- GET all destinations: python @app.route('/destinations', methods=['GET']) def get_destinations(): destinations = Destination.query.all() return jsonify([d.to_dict() for d in destinations])
- GET single destination by ID: python @app.route('/destinations/<int:destination_id>', methods=['GET']) def get_destination(destination_id): d = Destination.query.get(destination_id) if d: return jsonify(d.to_dict()) return jsonify({'error': 'destination not found'}), 404
- POST (create) a new destination: python @app.route('/destinations', methods=['POST']) def add_destination(): data = request.get_json() new_destination = Destination( destination=data['destination'], country=data['country'], rating=data['rating'] ) db.session.add(new_destination) db.session.commit() return jsonify(new_destination.to_dict()), 201
- PUT (update) a destination by ID: python @app.route('/destinations/<int:destination_id>', methods=['PUT']) def update_destination(destination_id): data = request.get_json() d = Destination.query.get(destination_id) if d: d.destination = data.get('destination', d.destination) d.country = data.get('country', d.country) d.rating = data.get('rating', d.rating) db.session.commit() return jsonify(d.to_dict()) return jsonify({'error': 'destination not found'}), 404
- DELETE a destination by ID: python @app.route('/destinations/<int:destination_id>', methods=['DELETE']) def delete_destination(destination_id): d = Destination.query.get(destination_id) if d: db.session.delete(d) db.session.commit() return jsonify({'message': 'destination was deleted'}) return jsonify({'error': 'destination not found'}), 404
Notes about database sessions
- For changes (add/update/delete), call db.session.add() (if adding) then db.session.commit() to persist.
- Query using Model.query.get(id) or Model.query.all().

Testing the API with Postman

Ensure the Flask app is running (default server URL: http://127.0.0.1:5000 or http://localhost:5000).
Open Postman; create a collection (optional) and new requests.

Example requests:

GET all:
- GET http://localhost:5000/destinations
GET by ID:
- GET http://localhost:5000/destinations/3
POST (create):
- POST http://localhost:5000/destinations
- Body → raw → JSON, example: json {"destination":"Tokyo","country":"Japan","rating":4.5}
PUT (update):
- PUT http://localhost:5000/destinations/3
- Body → raw → JSON with updated fields
DELETE:
- DELETE http://localhost:5000/destinations/1

Confirm responses and status codes (e.g., 201 for POST creation, 200 for successful GET/PUT/DELETE, 404 when resource missing). Use Postman’s response panel to inspect JSON and status codes.

Practical tips & gotchas

JSON is like a Python dict; use request.get_json() to parse incoming JSON in Flask.
Always verify the server is running and that the correct port/URL is used in Postman.
Use debug=True while developing so Flask reloads on code changes.
Generate a requirements.txt for reproducibility.
Use an ORM (SQLAlchemy) to write Python code instead of raw SQL.
Return appropriate HTTP status codes (201 on successful create; 404 on missing resource).
The backend defines the domain and URIs — the front end calls them.

Speakers and sources

Speaker / Presenter:
- Josh (host of the video series “Code with Josh”)
Tools / Technologies mentioned:
- Python
- Flask
- Flask‑SQLAlchemy / SQLAlchemy (ORM)
- SQLite (example DB)
- JSON (data format)
- Postman (API testing)
- VS Code (editor)