Hassansin,

I spent a whole afternoon wrestling with multiple geocoding services to try and get a reasonable parse of address strings — your lib (hassansin/parse-address) did the job in 20min!

I can't thank you enough for your hard work on parse-address. You've done a wonderful job and you have my heartfelt thanks.

-Dan

I noticed your tests don't have any output, do you prefer it like that or would you like a PR?

Also, can you provide a test case for:

TODO:
Freeform Address parser

I am trying to use this package to parse a large amount of GIS data on a node server, and I'm running into an issue in that parseLocation takes almost 500 milliseconds to parse just one string. As I need to parse upwards of 10,000 strings for each data set, this creates quite a hangup on my server!

My use cases all look something like parseLocation('NW GRANT AV') -- in each case I just need to separate out the directional prefix and street type from the street name. Am I doing something wrong which is causing it to take this long, or is this just the approximate expected time for the parser to complete?

Thanks in advance for any response.

11201 CEDAR LAKE DR 1E or 345 N Ace Drive 4A are examples of this. The first parses the E as the suffix and the second drops 4A altogether

parseLocation returns city as "Marthas Vineyard" instead of "Martha's Vineyard"

When using the address parser, I would like an option for skipping the abbreviating of address components like state and street type.

For example:

var parser = require('parse-address');
var parsed = parser.parseLocation('1005 N Gravenstein Highway Sebastopol CA 95472');

// produces...
{ number: '1005',
  prefix: 'N',
  street: 'Gravenstein',
  type: 'Hwy',
  city: 'Sebastopol',
  state: 'CA',
  zip: '95472' }

With the new feature, all sub-strings would remain unmodified if desired:

var parser = require('parse-address');
var parsed = parser.parseLocation('1005 N Gravenstein Highway Sebastopol CA 95472',
                                  skipAbbrev=true); // or some other flag to skip abbreviation

// produces...
{ number: '1005',
  prefix: 'N',
  street: 'Gravenstein',
  type: 'Highway', // doesn't abbreviate
  city: 'Sebastopol',
  state: 'CA', // leaves abbreviated
  zip: '95472' }

We are using this library in our application. Has worked fairly well for most of the US addresses, however fails for certain unusual valid ones like - "N95W18000 Appleton Ave, Menomonee Falls, WI 53051" or other highway addresses. Can this library be enhanced to handle those ?

I tried to parse 21B-Mercury-Drive-Londonderry-NH-03053

result:

  number: '21',
  street: 'B-Mercury',
  type: 'Dr',
  city: 'Londonderry',
  state: 'NH',
  zip: '03053'
}

21B is the number of the property. Since the "B" is attached to the street, am not able to solve my problem.

Any suggestions?

I'm not sure how easy this is to fix but I've found that the following address 1104 Watkins Glen Ct 104, Marysville, OH 43040 will cause the unit number to be included in the street instead of being set as the unit number.

Hi! Here it says that this package is being distributed under the ISC license -- is that true? If so, would you accept a pull request to add a file with the text of the license and some license headers?

Thanks!

P.S. -- excited to use the library, thanks for porting it to node js!

Hello,

The following address fails to parse properly:

PO Box 1400 Columbus, GA 33902-1200

It returns only:
sec_unit_num: "1200"
sec_unit_type: "PO Box"
street: "Columbus"

According to the USPS, it is valid to have only the PO box. Perhaps PO box should have a special case?

http://pe.usps.gov/text/pub28/28c2_005.htm

Parsing of 4505 ravenwood pl union city ga results in

{
  "number": "4505",
  "street": "ravenwood pl",
  "type": "Un",
  "city": "city",
  "state": "ga"
}

while it should be

{
  "number": "4505",
  "street": "ravenwood",
  "type": "pl",
  "city": "union city",
  "state": "ga"
}

Adding , after street name helps, but it's not always possible.

7/8 St, Turtle Lake WI returns 7 8 St

Hi,

I've been using this package in my application and it works great for most of the US addresses. However, I recently figured out that certain addresses in the US state of Alaska are causing this to break.

For example:
"HC 60 Box 2840, Haines, AK 99827" is a valid address in Alaska. But parsing it is only returning Street. I get the following response:

{street: "hc"}

Can this be looked into? Thanks a million!

Given the following:
1800 N, Lehi, UT 84043, USA

I would expect to see

{
  number: '1800',
  street: 'N',
  city: 'Lehi',
  state: 'UT',
  zip: '84043'
}

Instead I get:

{
	number: '1800',
  prefix: 'N',
  street: 'Lehi',
}

Should USA just be omitted? Given that this just parses US addresses?

The test fails when there is a country in the address, but without a country, it works perfectly.
Example:
Fails to parse the address correctly - 6516 East Calle Bellatrix, Tucson, AZ 85710, USA
Pass: 6516 East Calle Bellatrix, Tucson, AZ 85710

We have an html input for address entry. We use Google Maps Autocomplete to provide suggestions. Google Maps doesn't handle secondary designators very well during interactive input, so we use parse-address to remove the secondary designator. For this reason, it's important that parse-address acts consistently with partial input (as the user is typing).

Input: "10 miller pl Unit 505, san fran"
Output: {"number":"10","street":"miller","type":"Pl","sec_unit_type":"Unit","sec_unit_num":"505"}
Comment: Correctly identifies secondary information as "Unit 505"

However--

Input: "10 miller pl #505, san fran"
Output: {"number":"10","street":"miller","type":"Pl"}
Comment: Does not correctly identify secondary information as "#505" until the entire address is completely entered.

Input: "10 miller pl #505, san francisco, ca"
Output: {"number":"10","street":"miller","type":"Pl","sec_unit_type":"Unit","sec_unit_num":"505"}
Comment: Correctly identifies all components.

address parse error

1. 1784 N St NW, Washington, DC 20036, United States
2. 328 Massachusetts Ave NE # 4, Washington, DC 20002, United States

What causes parsed to return null. For validation purposes.
I suppose when var parts = XRegExp.exec(address,Addr_Match.informal_address); returns null?

Would be happy to contribute Canada address parsing to this repo, but wondering if other people are interested in this

Thanks!

The string "1005 Gravenstein Hwy 95472" parses to

{
    number: '1005',
    street: 'Gravenstein',
    type: 'Hwy',
    zip: '95472'
  }

"1005 Gravenstein Hwy 95472 &" returns null

Could you please provide TypeScript definitions either in the repo, or in DefinitelyTyped?

If I type 90291-3064 in as the address (either by itself or at the end of a street address) I'd expect the parser to be able to identify this as a Zip+4 format but instead it either truncates the +4 part of the zip when it is hanging off a street address or associates the +4 part as being a street number.

Running parseLocation inside a React app that a submodule inside a larger Gatsby project.

Getting a strange error when using parser.parseLocation(value). Browser is returning 'undefined is not a function.' Line 521 of parseaddress/address.js. Here's the full block:

    Addr_Match = {
      type    : flatten(Street_Type).sort().filter(function(v,i,arr){return arr.indexOf(v)===i }).join('|'),
      fraction : '\\d+\\/\\d+',
      state   : '\\b(?:' + keys(State_Code).concat(values(State_Code)).map(XRegExp.escape).join('|') + ')\\b',
      direct  : values(Directional).sort(function(a,b){return a.length < b.length}).reduce(function(prev,curr){return prev.concat([XRegExp.escape(curr.replace(/\w/g,'$&.')),curr])},keys(Directional)).join('|'),
      dircode : keys(Direction_Code).join("|"),
      zip     : '(?<zip>\\d{5})[- ]?(?<plus4>\\d{4})?',
      corner  : '(?:\\band\\b|\\bat\\b|&|\\@)',
    };

I suspect it's related to how XRegExp is being required at the top of the same file:

   XRegExp = __webpack_require__(/*! xregexp/src/xregexp.js */ "./node_modules/xregexp/src/xregexp.js");

Encounter a similar issue when running parser.parseAddress(value). Browser returns error: 'XRegExp.exec is not a function'. Line 682 of parseaddress/address.js:

  parser.parseAddress = function(address){
    lazyInit();
    var parts = XRegExp.exec(address,Addr_Match.address);
    return parser.normalize_address(parts);
  };

I've confirmed that xregexp is also an installed dependency.

Please advice when you get a chance, thanks!

var parseAddress = require("parse-address")

var parsed = parseAddress.parseLocation('Sebastopol CA');

--> street: "Sebastopol"

When the script find a address with 2 possible street type, it grabs the first one as street type and not the last. Blvd should be considered the street type, and not Beach, but it is now ignored and left as part of the City name

760 South Beach Blvd La Habra, CA 90631-6416

the result is

{ "number": "760", "street": "South", "type": "Bch", "city": "Blvd La Habra", "state": "CA", "zip": "90631", "plus4": "6416" }