Question: How optimize an API call in symfony?

I call with Guzzle bundle, but the time in some situations is very long.

In client application call a function from the server. 
In server application extract the objects from the database and send back to the client.
In client creat the new object with properties from server respons.

Answer: 
One of the ways to improve your API calls is to use caching. In Symfony there are many different ways to achieve this. I can show you one of them (`PhpFileCache` example):

In **services.yml** create cache service:

```
your_app.cache_provider:
    class: Doctrine\Common\Cache\PhpFileCache
    arguments: ["%kernel.cache_dir%/path_to/your_cache_dir", ".your.cached_file_name.php"]

```

(Remember, you need `Doctrine` extension in your app to work)

Then pass your caching service `your_app.cache_provider` to any service where you need caching:

Again in your **services.yml**:

```
some_service_of_yours:
    class: AppBundle\Services\YourService
    arguments: ['@your_app.cache_provider']

```

Finally, in your service (where you want to perform API caching):

```
use Doctrine\Common\Cache\CacheProvider;

class YourService
{
    private $cache;

    public function __construct(CacheProvider $cache)
    {
        $this->cache = $cache;
    }

    public function makeApiRequest()
    {
        $key = 'some_unique_identifier_of_your_cache_record';

        if(!$data = $this->cache->fetch($key))
        {
            $data = $provider->makeActualApiCallHere('http://some_url');
            $this->cache->save($key, serialize($data), 10800); //10800 here is amount of seconds to store your data in cache before its invalidated, change it to your needs
        }

        return $data; // now you can use the data
    } 
}

```

This is quite GENERIC example, you should change it to your exact needs, but idea is simple. You can cache data and avoid unnecessary API calls to speed things up. Be careful though, because cache has drawback of presenting stale(obsolete) data. Some things can (and should) be cached, but some things don't.
**If you control the server**

You should put a cache reverse proxy like Varnish on top of your PHP server. The PHP app must send HTTP cache headers to tell to the proxy how many time it must cache the request. Alternatively, you can use a library like [FOSHttpCache](http://foshttpcachebundle.readthedocs.io/en/latest/) to setup a cache invalidation strategy (the PHP server will purge the cache from the proxy when an update of the data occurs - it's a more advanced and complex scenario).
The PHP server will not even be called if the requested resource is in the reverse proxy cache.

You should also use a profiler like Blackfire.io or xhprof to find why some parts of your PHP code (or your SQL queries) take so many time to be executed, then optimize.

**If you control the client**

You can use [this HTTP cache middleware for Guzzle](https://github.com/Kevinrob/guzzle-cache-middleware) to cache every API result according to HTTP headers sent by the API.