# body parser

***

**1. Simple JSON parsing**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json());

app.post('/json', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**2. Parsing extended forms (with file uploads)**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.urlencoded({ extended: true }));

app.post('/form', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**3. Limiting the size of request bodies**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json({ limit: '10mb' })); // Limit to 10 MB

app.post('/json', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**4. Type-checking request bodies**

```ts
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json({ type: 'application/json' }));

app.post('/json', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**5. Customizing the error handling middleware**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json({
  verify: (req, res, buf) => {
    // Custom error handling logic
  }
}));

app.post('/json', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**6. Using multiple middlewares**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use([
  bodyParser.json({ limit: '10mb' }),
  bodyParser.urlencoded({ extended: true })
]);

app.post('/data', (req, res) => {
  // Parse both JSON and form data
  console.log(req.body);
  res.send('OK');
});
```

**7. Parsing raw text bodies**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.text()); // Parse text/plain

app.post('/text', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**8. Parsing multipart/form-data**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.multipart());

app.post('/multipart', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**9. Using the raw API**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
const rawParser = bodyParser.raw();

app.post('/raw', rawParser, (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**10. Using the text API**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
const textParser = bodyParser.text();

app.post('/text', textParser, (req, res) => {
  console.log(req.body);
});
```

**11. Parsing and verifying JSON Web Tokens (JWTs)**

```js
const express = require('express');
const bodyParser = require('body-parser');
const jwt = require('jsonwebtoken');

const app = express();
app.use(bodyParser.json());

app.post('/auth', (req, res) => {
  const token = req.body.token;
  jwt.verify(token, 'secret', (err, decoded) => {
    if (err) {
      res.status(401).send('Invalid token');
    } else {
      res.send(decoded);
    }
  });
});
```

**12. Parsing and validating GraphQL queries**

```js
const express = require('express');
const bodyParser = require('body-parser');
const gql = require('graphql-tag');
const validate = require('graphql').validate;
const introspectionQuery = require('graphql/utilities').introspectionQuery;

const app = express();
app.use(bodyParser.json());

app.post('/graphql', (req, res) => {
  const query = req.body.query;
  const result = validate(introspectionQuery, gql(query));
  if (!result.valid) {
    res.status(400).send(result.errors);
  } else {
    res.send(result);
  }
});
```

**13. Parsing and validating Protobuf messages**

```js
const express = require('express');
const bodyParser = require('body-parser');
const protobuf = require('protobufjs');

const app = express();
app.use(bodyParser.raw());

app.post('/protobuf', (req, res) => {
  const Message = protobuf.load('messages.proto').lookupType('MyMessage');
  const message = Message.decode(req.body);
  if (message.validate()) {
    res.send(message.toJSON());
  } else {
    res.status(400).send('Invalid Protobuf message');
  }
});
```

**14. Using the form-data API**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.formData());

app.post('/form-data', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**15. Using the urlencoded API**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.urlencoded({ extended: true }));

app.post('/urlencoded', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**16. Using the json API**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json());

app.post('/json', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**17. Using the raw API with a custom encoding**

```js
const express = require('express');
const bodyParser = require('body-parser');
const iconv = require('iconv-lite');

const app = express();
app.use(bodyParser.raw({
  encoding: 'base64'
}));

app.post('/raw-base64', (req, res) => {
  const decodedBody = iconv.decode(req.body, 'base64');
  console.log(decodedBody);
  res.send('OK');
});
```

**18. Parsing JSON without a Content-Type header**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json({
  strict: false
}));

app.post('/json', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**19. Parsing JSON from a POST request with no body**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json({
  strict: false,
  inflate: true
}));

app.post('/json', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**20. Parsing JSON from an X-Forwarded-Raw request body**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json({
  verify: (req, res, buf) => {
    if (req.headers['x-forwarded-raw']) {
      req.rawBody = buf;
    }
  }
}));

app.post('/json', (req, res) => {
  if (req.rawBody) {
    console.log(req.rawBody);
  } else {
    console.log(req.body);
  }
  res.send('OK');
});
```

**21. Parsing JSON using a custom type**

```ts
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json({
  type: 'application/vnd.example+json'
}));

app.post('/custom-json', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**22. Parsing JSON with a depth limit**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json({
  depth: 5
}));

app.post('/json', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**23. Parsing JSON with a reviver function**

```js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json({
  reviver: (key, value) => {
    return value;
  }
}));

app.post('/json', (req, res) => {
  console.log(req.body);
  res.send('OK');
});
```

**24. Using the formidable middleware**

```js
const express = require('express');
const formidable = require('formidable');

const app = express();
app.use(formidable());

app.post('/upload', (req, res) => {
  console.log(req.files);
  console.log(req.fields);
  res.send('OK');
});
```

**25. Using the multer middleware**

```js
const express = require('express');
const multer = require('multer');

const app = express();
app.use(multer().single('photo'));

app.post('/upload', (req, res) => {
  console.log(req.file);
  res.send('OK');
});
```