W moim przypadku nie wystarczyło dodać tych linijek:

var bodyParser = require('body-parser');
app.use(bodyParser.json({limit: '50mb'}));
app.use(bodyParser.urlencoded({limit: '50mb', extended: true}));

Próbowałem dodać opcję parameterLimit w funkcji urlencoded, jak mówi dokumentacja i błąd nie pojawia się.

Opcja parameterLimit kontroluje maksymalną liczbę parametrów które są dozwolone w danych zakodowanych URL. Jeżeli wniosek zawiera więcej parametry niż ta wartość, 413 zostanie zwrócony do klienta. Domyślnie 1000.

Spróbuj z tym kodem:

var bodyParser = require('body-parser');
app.use(bodyParser.json({limit: "50mb"}));
app.use(bodyParser.urlencoded({limit: "50mb", extended: true, parameterLimit:50000}));

Jeśli ktoś spróbował wszystkich odpowiedzi, ale nie odniósł jeszcze żadnego sukcesu i używa NGINX do hostowania strony, Dodaj tę linię do /etc / nginx / sites-available

client_max_body_size 100M; #100mb

Myślę, że nie jest to limit rozmiaru express global, ale konkretnie connect.JSON middleware limit . Domyślnie jest to 100KB, gdy używasz express.bodyParser() i nie podajesz opcji limit.

Spróbuj:

app.post('/api/0.1/people', express.bodyParser({limit: '5mb'}), yourHandler);

W moim przypadku .. ustawienie parameterLimit:50000 naprawiono problem

app.use( bodyParser.json({limit: '50mb'}) );
app.use(bodyParser.urlencoded({
  limit: '50mb',
  extended: true,
  parameterLimit:50000
}));

2016, żaden z powyższych nie zadziałał dla mnie, dopóki explicity nie ustawił "type" oprócz "limit" dla bodyparser, przykład:

  var app = express();
  var jsonParser       = bodyParser.json({limit:1024*1024*20, type:'application/json'});
  var urlencodedParser = bodyParser.urlencoded({ extended:true,limit:1024*1024*20,type:'application/x-www-form-urlencoded' })

  app.use(jsonParser);
  app.use(urlencodedParser);

Następujące zadziałały dla mnie... Wystarczy użyć

app.use(bodyParser({limit: '50mb'}));

app.use(bodyParser());
app.use(bodyParser({limit: '50mb'}));
app.use(bodyParser.urlencoded({limit: '50mb'}));

Zdefiniowano tylko pierwszą app.use(bodyParser());, a dwie ostatnie linie zostały zignorowane.

Zobacz: https://github.com/expressjs/body-parser/issues/176 > > zobacz 'dougwilson skomentował 17 czerwca 2016'

Dla express ~4.16.0, express.json z limitem działa bezpośrednio

app.use(express.json({limit: '50mb'}));

W moim przypadku problem był na konfiguracji Nginx. Aby go rozwiązać, muszę edytować plik: /etc/nginx/nginx.conf i dodać tę linię wewnątrz bloku serwera:

client_max_body_size 5M;

sudo systemctl restart nginx

Po wielu próbach mam swoje rozwiązanie

Skomentowałem ten wiersz

app.use(bodyParser.json());

And I put

app.use(bodyParser.json({limit: '50mb'}))

Then it works

Użyłem innej praktyki w tym problemie z multi zależnością.

Przykład:

multer = require('multer');

var uploading = multer({
  limits: {fileSize: 1000000, files:1},
});

exports.uploadpictureone = function(req, res) {
  cloudinary.uploader.upload(req.body.url, function(result) {
    res.send(result);
  });
};

module.exports = function(app) {
    app.route('/api/upload', uploading).all(uploadPolicy.isAllowed)
        .post(upload.uploadpictureone);
};

Mały stary post ale miałem ten sam problem

Za pomocą express 4.+ mój kod wygląda tak i działa świetnie po dwóch dniach intensywnych testów.

var url         = require('url'),
    homePath    = __dirname + '/../',
    apiV1       = require(homePath + 'api/v1/start'),
    bodyParser  = require('body-parser').json({limit:'100mb'});

module.exports = function(app){
    app.get('/', function (req, res) {
        res.render( homePath + 'public/template/index');
    });

    app.get('/api/v1/', function (req, res) {
        var query = url.parse(req.url).query;
        if ( !query ) {
            res.redirect('/');
        }
        apiV1( 'GET', query, function (response) {
            res.json(response);
        });
    });

    app.get('*', function (req,res) {
        res.redirect('/');
    });

    app.post('/api/v1/', bodyParser, function (req, res) {
        if ( !req.body ) {
            res.json({
                status: 'error',
                response: 'No data to parse'
            });
        }
        apiV1( 'POST', req.body, function (response) {
            res.json(response);
        });
    });
};

Nieco inne podejście - ładunek jest za duży

Wszystkie pomocne odpowiedzi do tej pory dotyczą zwiększenia limitu ładowności. Ale może być też tak, że ładowność jest rzeczywiście zbyt duża, ale bez dobrego powodu. Jeśli nie ma ważnego powodu, zastanów się, dlaczego jest tak rozdęty w pierwszej kolejności.

Nasze własne doświadczenia

Na przykład, w naszym przypadku, aplikacja kątowa chciwie wysyłała cały obiekt w ładunku. Gdy jeden usunięto nadęty i zbędny obiekt, wielkość ładunku została zmniejszona o współczynnik 100. To znacznie poprawiło wydajność i rozwiązało błąd 413.

Dla mnie po snippet rozwiązał problem.

var bodyParser = require('body-parser');
app.use(bodyParser.json({limit: '50mb'})); 

W moim przypadku usunięcie Content-type z nagłówków żądania zadziałało.

Im lepiej użyć, możesz określić limit rozmiaru pliku, Jak pokazano w podanych wierszach:

app.use(bodyParser.json({limit: '10mb', extended: true}))
app.use(bodyParser.urlencoded({limit: '10mb', extended: true}))

Możesz również zmienić domyślne ustawienie w node-modules body-parser, a następnie w folderze lib znajdują się pliki JSON i tekstowe. Następnie zmień limit tutaj. W rzeczywistości warunek ten przejdzie, jeśli nie przekażesz parametru limit w podanej linii app.use (bułg.json ({limit: '10MB', extended: true})).

Jeśli używasz express.json() i bodyParser razem, spowoduje to błąd, ponieważ express ustawia swój własny limit.

app.use(express.json());
app.use(express.urlencoded({ extended: false }));

Usuń powyższy kod i po prostu dodaj poniższy kod

app.use(bodyParser.json({ limit: "200mb" }));
app.use(bodyParser.urlencoded({ limit: "200mb",  extended: true, parameterLimit: 1000000 }));

Ja też miałem do czynienia z tym problemem, popełniłem głupi błąd powtarzając app.use(bodyParser.json()) Jak poniżej:

app.use(bodyParser.json())
app.use(bodyParser.json({ limit: '50mb' }))

Usuwając app.use(bodyParser.json()), rozwiązaliśmy problem.

Ostatnio spotkałem się z tym samym problemem i poniżej rozwiązanie działa dla mnie.

Dependency : 
express >> version : 4.17.1
body-parser >> version": 1.19.0

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

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

Dla zrozumienia : HTTP 431

Zbyt duży kod statusu odpowiedzi HTTP 413 wskazuje, że encja żądania jest większa niż limity określone przez serwer; serwer może zamknąć połączenie lub zwrócić pole nagłówka Retry-After.

Ustawienie poniżej działa dla mnie

Express 4.16.1

app.use(bodyParser.json({ limit: '50mb' }))
app.use(bodyParser.urlencoded({
  limit: '50mb',
  extended: false,
}))

Nginx

client_max_body_size 50m
client_body_temp_path /data/temp

Dla mnie główną sztuczką jest

app.use(bodyParser.json({
  limit: '20mb'
}));

app.use(bodyParser.urlencoded({
  limit: '20mb',
  parameterLimit: 100000,
  extended: true 
}));

BodyParse.JSON first bodyParse.urlencoded second

Dla tych, którzy uruchamiają aplikację NodeJS na Azure w ramach IIS, nie zapomnij zmodyfikować sieci.config jak wyjaśniono tutaj Azure App Service IIS ustawienie "maxRequestLength"

Express 4.17.1

app.use( express.urlencoded( {
    extended: true,
    limit: '50mb'
} ) )

Demo csb