The main HTTP methods (verbs) used in REST APIs are:

• GET: Retrieves data from the server. Should be safe and idempotent.
• POST: Creates new resources or submits data for processing.
• PUT: Updates an entire resource or creates it if it doesn't exist. Should be idempotent.
• PATCH: Partially updates a resource.
• DELETE: Removes a resource. Should be idempotent.
• HEAD: Similar to GET but returns only headers, not the body.
• OPTIONS: Returns allowed methods for a resource.

Example:

GET /users/123        # Retrieve user with ID 123
POST /users           # Create a new user
PUT /users/123        # Update entire user 123
PATCH /users/123      # Partially update user 123
DELETE /users/123     # Delete user 123

HTTP status codes are three-digit numbers that indicate the result of an HTTP request. They are grouped into five categories:

1xx - Informational:

• 100 Continue

2xx - Success:

• 200 OK: Request successful
• 201 Created: Resource successfully created
• 204 No Content: Successful but no content to return

3xx - Redirection:

• 301 Moved Permanently
• 304 Not Modified

4xx - Client Error:

• 400 Bad Request: Invalid request syntax
• 401 Unauthorized: Authentication required
• 403 Forbidden: Access denied
• 404 Not Found: Resource doesn't exist
• 409 Conflict: Request conflicts with current state

5xx - Server Error:

• 500 Internal Server Error
• 503 Service Unavailable

The key differences between PUT and POST are:

PUT:

• Idempotent: Multiple identical requests have the same effect
• Specific target: Usually targets a specific resource with known identifier
• Replace/Create: Replaces entire resource or creates if doesn't exist
• Safe to retry: Can be safely retried without side effects

POST:

• Not idempotent: Multiple requests may have different effects
• Collection target: Usually targets a collection to create new resources
• Create/Process: Creates new resources or processes data
• Not safe to retry: May create duplicate resources if retried

Examples:

PUT /users/123     # Replace/update user 123 specifically
POST /users        # Create a new user (server assigns ID)

An API is considered RESTful when it adheres to REST architectural constraints:

1. Uniform Interface: Consistent resource identification (URLs), manipulation through representations, self-descriptive messages, and HATEOAS
2. Stateless: Each request is independent and contains all necessary information
3. Cacheable: Responses indicate whether they can be cached
4. Client-Server: Clear separation of concerns
5. Layered System: Can include intermediary layers (proxies, gateways)
6. Code on Demand (optional): Server can send executable code to client

Additionally, RESTful APIs typically:

• Use standard HTTP methods appropriately
• Return appropriate HTTP status codes
• Use resource-based URLs (nouns, not verbs)
• Support multiple representations (JSON, XML)

A resource in REST is any piece of information that can be named and accessed via a URI (Uniform Resource Identifier). Resources are the key abstraction in REST architecture.

Characteristics of resources:

• Identifiable: Each resource has a unique URI
• Representable: Can be represented in different formats (JSON, XML, HTML)
• Stateless: The resource's representation captures its current state
• Manipulable: Can be created, read, updated, or deleted

Examples:

• A user: /users/123
• A collection of users: /users
• A user's orders: /users/123/orders
• A specific order: /orders/456

Resources should be nouns, not verbs, and represent entities or collections of entities in your domain.

These are related but distinct concepts:

URI (Uniform Resource Identifier):

• Generic term for any identifier that identifies a resource
• Superset that includes both URLs and URNs
• Example: mailto:john@example.com

URL (Uniform Resource Locator):

• Type of URI that specifies location and method to access a resource
• Includes protocol, domain, and path
• Example: https://api.example.com/users/123

URN (Uniform Resource Name):

• Type of URI that identifies a resource by name in a specific namespace
• Location-independent identifier
• Example: urn:isbn:0451450523

In REST APIs, we primarily work with URLs to locate and access resources over HTTP.