What are idempotent and/or safe methods?
Safe methods are HTTP methods that do not modify resources. For instance, using [GET] or [HEAD] on a resource URL, should NEVER change the resource. However, this is not completely true. It means: it won't change the resource representation. It is still possible, that safe methods do change things on a server or resource, but this should not reflect in a different representation.
This means the following is incorrect, if this would actually delete the blogpost:
Safe methods are methods that can be cached, prefetched without any repercussions to the resource.
An idempotent HTTP method is a HTTP method that can be called many times without different outcomes. It would not matter if the method is called only once, or ten times over. The result should be the same. Again, this only applies to the result, not the resource itself. This still can be manipulated (like an update-timestamp, provided this information is not shared in the (current) resource representation.
Consider the following examples:
The first example is idempotent: no matter how many times we execute this statement, a will always be 4. The second example is not idempotent. Executing this 10 times will result in a different outcome as when running 5 times. Since both examples are changing the value of a, both are non-safe methods.
Idempotency is important in building a fault-tolerant API. Suppose a client wants to update a resource through [POST]. Since [POST] is not a idempotent method, calling it multiple times can result in wrong updates. What would happen if you sent out the [POST] request to the server, but you get a timeout. Is the resource actually updated? Does the timeout happened during sending the request to the server, or the response to the client? Can we safely retry again, or do we need to figure out first what has happened with the resource? By using idempotent methods, we do not have to answer this question, but we can safely resend the request until we actually get a response back from the server.
Be careful when dealing with safe methods as well: if a seemingly safe method like [GET] will change a resource, it might be possible that any middleware client proxy systems between you and the server, will cache this response. Another client who wants to change this resource through the same URL (like: http://example.org/api/article/1234/delete), will not call the server, but return the information directly from the cache. Non-safe (and non-idempotent) methods will never be cached by any middleware proxies
Overview of (some) HTTP methods