# superagent

***

**1. GET Request with Query Parameters:**

```js
const request = require('superagent');

request
  .get('https://example.com/api/v1/products')
  .query({
    page: 1,
    limit: 10,
    category: 'electronics',
  })
  .then(res => {
    console.log(res.body);
  })
  .catch(err => {
    console.error(err);
  });
```

**2. POST Request with JSON Body:**

```js
const request = require('superagent');

request
  .post('https://example.com/api/v1/orders')
  .send({
    items: [
      {
        product_id: 1,
        quantity: 2,
      },
      {
        product_id: 2,
        quantity: 1,
      },
    ],
  })
  .then(res => {
    console.log(res.body);
  })
  .catch(err => {
    console.error(err);
  });
```

**3. PUT Request to Update Resource:**

```js
const request = require('superagent');

request
  .put('https://example.com/api/v1/products/1')
  .send({
    name: 'Updated Product Name',
    description: 'Updated Product Description',
  })
  .then(res => {
    console.log(res.body);
  })
  .catch(err => {
    console.error(err);
  });
```

**4. DELETE Request to Remove Resource:**

```js
const request = require('superagent');

request
  .delete('https://example.com/api/v1/products/1')
  .then(res => {
    console.log('Product deleted successfully!');
  })
  .catch(err => {
    console.error(err);
  });
```

**5. Using Promises with Superagent:**

```js
const request = require('superagent');

const getProducts = async () => {
  const response = await request
    .get('https://example.com/api/v1/products')
    .query({
      page: 1,
      limit: 10,
    });
  return response.body;
};
```

**6. Error Handling with Superagent:**

```js
const request = require('superagent');

request
  .get('https://example.com/api/v1/products/1')
  .catch(err => {
    if (err.status === 404) {
      console.log('Product not found!');
    } else {
      console.error(err);
    }
  });
```

**7. Using Superagent with Express.js:**

```js
const request = require('superagent');
const express = require('express');

const app = express();

app.get('/products', (req, res) => {
  request
    .get('https://example.com/api/v1/products')
    .query(req.query)
    .then(response => {
      res.json(response.body);
    })
    .catch(err => {
      res.status(500).send(err.message);
    });
});
```

**8. Using Superagent to Scrape a Website:**

```js
const request = require('superagent');
const cheerio = require('cheerio');

request
  .get('https://example.com')
  .then(response => {
    const $ = cheerio.load(response.text);
    const title = $('title').text();
    console.log(title);
  })
  .catch(err => {
    console.error(err);
  });
```

**9. Using Superagent with Async/Await:**

```js
const request = require('superagent');

const getProducts = async () => {
  const response = await request
    .get('https://example.com/api/v1/products')
    .query({
      page: 1,
      limit: 10,
    });
  return response.body.products;
};
```

**10. Using Superagent with Proxy:**

```js
const request = require('superagent');
const httpProxyAgent = require('http-proxy-agent');

const agent = new httpProxyAgent('http://proxy.example.com:80');

request
  .get('https://example.com')
  .agent(agent)
  .then(res => {
    console.log(res.text);
  })
  .catch(err => {
    console.error(err);
  });
```

**11. Using Superagent to Upload a File:**

```js
const request = require('superagent');

const formData = new FormData();
formData.append('file', fs.createReadStream('myfile.txt'));

request
  .post('https://example.com/api/v1/uploads')
  .attach('file', 'myfile.txt')
  .then(res => {
    console.log(res.body);
  })
  .catch(err => {
    console.error(err);
  });
```

**12. Using Superagent to Perform OAuth Authentication:**

```js
const request = require('superagent');
const OAuth2 = require('oauth').OAuth2;

const oauth2 = new OAuth2(
  clientId,
  clientSecret,
  'https://example.com/oauth/request_token',
  'https://example.com/oauth/access_token',
  'https://example.com/oauth/authorize'
);

const getAccessToken = async () => {
  const response = await oauth2.getOAuthAccessToken();
  return response.access_token;
};

const makeRequest = async accessToken => {
  const response = await request
    .get('https://example.com/api/v1/products')
    .set('Authorization', `Bearer ${accessToken}`);
  return response.body;
};
```

**13. Using Superagent to Retry Requests:**

```js
const request = require('superagent');

const makeRequest = url => {
  return request.get(url)
    .retry(5)
    .catch(err => {
      if (err.status === 503) {
        return makeRequest(url);
      } else {
        throw err;
      }
    });
};
```

**14. Using Superagent with Custom Error Handling:**

```js
const request = require('superagent');

const makeRequest = url => {
  return request.get(url)
    .then(res => {
      if (res.status !== 200) {
        throw new Error(`Error: ${res.status} ${res.text}`);
      }
      return res.body;
    });
};
```

**15. Using Superagent to Send Cookies:**

```js
const request = require('superagent');

const makeRequest = url => {
  return request.get(url)
    .set('Cookie', 'session_id=12345');
};
```

**16. Using Superagent with Timeout:**

```js
const request = require('superagent');

const makeRequest = url => {
  return request.get(url)
    .timeout(3000);
};
```

**17. Using Superagent to Parse JSON Responses:**

```js
const request = require('superagent');

const makeRequest = url => {
  return request.get(url)
    .set('Accept', 'application/json')
    .then(res => {
      return JSON.parse(res.text);
    });
};
```

**18. Using Superagent with Plugins:**

```js
const request = require('superagent');
const cachePlugin = require('superagent-cache');

const cachedRequest = request.use(cachePlugin());

const makeRequest = url => {
  return cachedRequest.get(url);
};
```

**19. Using Superagent with Transformers:**

```js
const request = require('superagent');
const transformer = require('superagent-xml2js');

const makeRequest = url => {
  return request.get(url)
    .use(transformer())
    .then(res => {
      return res.body;
    });
};
```

**20. Using Superagent to Send HTML Forms:**

```js
const request = require('superagent');

const makeRequest = url => {
  return request.post(url)
    .type('form')
    .send({
      username: 'johndoe',
      password: 'secretpassword',
    });
};
```

**21. Using Superagent to Handle HTTP Errors:**

```js
const request = require('superagent');

const makeRequest = url => {
  return request.get(url)
    .then(res => {
      if (res.status !== 200) {
        throw new Error(`Error: ${res.status} ${res.text}`);
      }
      return res.body;
    })
    .catch(err => {
      if (err.status === 404) {
        console.log('404 Not Found');
      } else {
        throw err;
      }
    });
};
```

**22. Using Superagent to Deal with Rate Limiting:**

```js
const request = require('superagent');
const delay = require('delay');

const makeRequest = url => {
  return request.get(url)
    .then(res => {
      if (res.headers['x-ratelimit-remaining'] === 0) {
        throw new Error('Rate limit exceeded');
      }
      return res.body;
    })
    .catch(err => {
      if (err.message === 'Rate limit exceeded') {
        return delay(1000).then(() => makeRequest(url));
      } else {
        throw err;
      }
    });
};
```

**23. Using Superagent for Parallel Requests:**

```js
const request = require('superagent');
const Promise = require('bluebird');

const makeRequests = urls => {
  const requests = urls.map(url => request.get(url));
  return Promise.all(requests);
};
```

**24. Using Superagent to Send Multipart/Form-Data:**

```js
const request = require('superagent');

const makeRequest = url => {
  const formData = new FormData();
  formData.append('file', fs.createReadStream('myfile.txt'));
  formData.append('name', 'John Doe');

  return request.post(url)
    .type('multipart/form-data')
    .send(formData);
};
```

**25. Using Superagent with API Keys:**

```js
const request = require('superagent');

const makeRequest = url => {
  return request.get(url)
    .set('Authorization', `Bearer ${apiKey}`);
};
```