diff --git a/bird_client.go b/bird_client.go
deleted file mode 100644
index 257b9e0..0000000
--- a/bird_client.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package main
-
-import (
-	"github.com/czerwonk/bird_exporter/parser"
-	"github.com/czerwonk/bird_exporter/protocol"
-	"github.com/czerwonk/bird_socket"
-)
-
-func getProtocols() ([]*protocol.Protocol, error) {
-	var protocols []*protocol.Protocol = nil
-	var err error = nil
-
-	if *birdV2 {
-		protocols, err = getProtocolsFromBird(*birdSocket, "")
-	} else {
-		protocols, err = getProtocolsFromBird1()
-	}
-
-	return protocols, err
-}
-
-func getProtocolsFromBird1() ([]*protocol.Protocol, error) {
-	protocols := make([]*protocol.Protocol, 0)
-
-	if *birdEnabled {
-		s, err := getProtocolsFromBird(*birdSocket, "4")
-		if err != nil {
-			return nil, err
-		}
-		protocols = append(protocols, s...)
-	}
-
-	if *bird6Enabled {
-		s, err := getProtocolsFromBird(*bird6Socket, "6")
-		if err != nil {
-			return nil, err
-		}
-		protocols = append(protocols, s...)
-	}
-
-	return protocols, nil
-}
-
-func getProtocolsFromBird(socketPath string, ipVersion string) ([]*protocol.Protocol, error) {
-	b, err := birdsocket.Query(socketPath, "show protocols all")
-	if err != nil {
-		return nil, err
-	}
-
-	return parser.Parse(b, ipVersion), nil
-}
diff --git a/client/bird_client.go b/client/bird_client.go
new file mode 100644
index 0000000..30a5ef7
--- /dev/null
+++ b/client/bird_client.go
@@ -0,0 +1,80 @@
+package client
+
+import (
+	"fmt"
+	"github.com/czerwonk/bird_exporter/parser"
+	"github.com/czerwonk/bird_exporter/protocol"
+	"github.com/czerwonk/bird_socket"
+)
+
+type BirdClient struct {
+	Options *BirdClientOptions
+}
+
+type BirdClientOptions struct {
+	BirdV2       bool
+	BirdEnabled  bool
+	Bird6Enabled bool
+	BirdSocket   string
+	Bird6Socket  string
+}
+
+func (c *BirdClient) GetProtocols() ([]*protocol.Protocol, error) {
+	ipVersions := make([]string, 0)
+	if c.Options.BirdV2 {
+		ipVersions = append(ipVersions, "")
+	} else {
+		if c.Options.BirdEnabled {
+			ipVersions = append(ipVersions, "4")
+		}
+
+		if c.Options.Bird6Enabled {
+			ipVersions = append(ipVersions, "6")
+		}
+	}
+
+	return c.protocolsFromBird(ipVersions)
+}
+
+func (c *BirdClient) GetOspfAreas(protocol *protocol.Protocol) ([]*protocol.OspfArea, error) {
+	sock := c.socketFor(protocol.IpVersion)
+	b, err := birdsocket.Query(sock, fmt.Sprintf("show ospf %s", protocol.Name))
+	if err != nil {
+		return nil, err
+	}
+
+	return parser.ParseOspf(b), nil
+}
+
+func (c *BirdClient) protocolsFromBird(ipVersions []string) ([]*protocol.Protocol, error) {
+	protocols := make([]*protocol.Protocol, 0)
+
+	for _, ipVersion := range ipVersions {
+		sock := c.socketFor(ipVersion)
+		s, err := c.protocolsFromSocket(sock, ipVersion)
+		if err != nil {
+			return nil, err
+		}
+
+		protocols = append(protocols, s...)
+	}
+
+	return protocols, nil
+}
+
+func (c *BirdClient) protocolsFromSocket(socketPath string, ipVersion string) ([]*protocol.Protocol, error) {
+	b, err := birdsocket.Query(socketPath, "show protocols all")
+	if err != nil {
+		return nil, err
+	}
+
+	return parser.ParseProtocols(b, ipVersion), nil
+}
+
+func (c *BirdClient) socketFor(ipVersion string) string {
+	if !c.Options.BirdV2 && ipVersion == "6" {
+		return c.Options.Bird6Socket
+	}
+
+	return c.Options.BirdSocket
+}
diff --git a/client/client.go b/client/client.go
new file mode 100644
index 0000000..ebb03a1
--- /dev/null
+++ b/client/client.go
@@ -0,0 +1,12 @@
+package client
+
+import "github.com/czerwonk/bird_exporter/protocol"
+
+type Client interface {
+
+	// GetProtocols retrieves protocol information and statistics from bird
+	GetProtocols() ([]*protocol.Protocol, error)
+
+	// GetOspfArea retrieves OSPF specific information from bird
+	GetOspfAreas(protocol *protocol.Protocol) ([]*protocol.OspfArea, error)
+}
diff --git a/main.go b/main.go
index 27d7dd6..db2ebe9 100644
--- a/main.go
+++ b/main.go
@@ -12,7 +12,7 @@ import (
 	"github.com/prometheus/common/log"
 )
 
-const version string = "1.1.0"
+const version string = "1.2.0"
 
 var (
 	showVersion   = flag.Bool("version", false, "Print version information.")
@@ -27,9 +27,9 @@ var (
 	enableStatic  = flag.Bool("proto.static", true, "Enables metrics for protocol Static")
 	enableDirect  = flag.Bool("proto.direct", true, "Enables metrics for protocol Direct")
 	// pre bird 2.0
-	bird6Socket   = flag.String("bird.socket6", "/var/run/bird6.ctl", "Socket to communicate with bird6 routing daemon (not compatible with -bird.v2)")
-	birdEnabled   = flag.Bool("bird.ipv4", true, "Get protocols from bird (not compatible with -bird.v2)")
-	bird6Enabled  = flag.Bool("bird.ipv6", true, "Get protocols from bird6 (not compatible with -bird.v2)")
+	bird6Socket  = flag.String("bird.socket6", "/var/run/bird6.ctl", "Socket to communicate with bird6 routing daemon (not compatible with -bird.v2)")
+	birdEnabled  = flag.Bool("bird.ipv4", true, "Get protocols from bird (not compatible with -bird.v2)")
+	bird6Enabled = flag.Bool("bird.ipv6", true, "Get protocols from bird6 (not compatible with -bird.v2)")
 )
 
 func init() {
@@ -76,41 +76,21 @@ func startServer() {
 			</body>
 			</html>`))
 	})
-	http.HandleFunc(*metricsPath, errorHandler(handleMetricsRequest))
+	http.HandleFunc(*metricsPath, handleMetricsRequest)
 
 	log.Infof("Listening for %s on %s\n", *metricsPath, *listenAddress)
 	log.Fatal(http.ListenAndServe(*listenAddress, nil))
 }
 
-func errorHandler(f func(http.ResponseWriter, *http.Request) error) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		err := f(w, r)
+func handleMetricsRequest(w http.ResponseWriter, r *http.Request) {
+	reg := prometheus.NewRegistry()
+	p := enabledProtocols()
+	c := NewMetricCollector(*newFormat, p)
+	reg.MustRegister(c)
 
-		if err != nil {
-			log.Errorln(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-		}
-	}
-}
-
-func handleMetricsRequest(w http.ResponseWriter, r *http.Request) error {
-	protocols, err := getProtocols()
-	if err != nil {
-		return err
-	}
-
-	if len(protocols) > 0 {
-		reg := prometheus.NewRegistry()
-		p := enabledProtocols()
-		c := NewMetricCollectorForProtocols(protocols, *newFormat, p)
-		reg.MustRegister(c)
-
-		promhttp.HandlerFor(reg, promhttp.HandlerOpts{
-			ErrorLog:      log.NewErrorLogger(),
-			ErrorHandling: promhttp.ContinueOnError}).ServeHTTP(w, r)
-	}
-
-	return nil
+	promhttp.HandlerFor(reg, promhttp.HandlerOpts{
+		ErrorLog:      log.NewErrorLogger(),
+		ErrorHandling: promhttp.ContinueOnError}).ServeHTTP(w, r)
 }
 func enabledProtocols() int {
 	res := 0
diff --git a/metric_collector.go b/metric_collector.go
index 67a32b1..6bff20e 100644
--- a/metric_collector.go
+++ b/metric_collector.go
@@ -1,43 +1,57 @@
 package main
 
 import (
+	"github.com/czerwonk/bird_exporter/client"
 	"github.com/czerwonk/bird_exporter/metrics"
-	"github.com/czerwonk/bird_exporter/ospf"
 	"github.com/czerwonk/bird_exporter/protocol"
 	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/common/log"
 )
 
 type MetricCollector struct {
-	protocols        []*protocol.Protocol
 	exporters        map[int][]metrics.MetricExporter
+	client           *client.BirdClient
 	enabledProtocols int
 }
 
-func NewMetricCollectorForProtocols(protocols []*protocol.Protocol, newFormat bool, enabledProtocols int) *MetricCollector {
+func NewMetricCollector(newFormat bool, enabledProtocols int) *MetricCollector {
+	c := getClient()
 	var e map[int][]metrics.MetricExporter
 
 	if newFormat {
-		e = exportersForDefault()
+		e = exportersForDefault(c)
 	} else {
-		e = exportersForLegacy()
+		e = exportersForLegacy(c)
 	}
 
-	return &MetricCollector{protocols: protocols, exporters: e, enabledProtocols: enabledProtocols}
+	return &MetricCollector{exporters: e, client: c, enabledProtocols: enabledProtocols}
 }
 
-func exportersForLegacy() map[int][]metrics.MetricExporter {
+func getClient() *client.BirdClient {
+	o := &client.BirdClientOptions{
+		BirdSocket:   *birdSocket,
+		Bird6Socket:  *bird6Socket,
+		Bird6Enabled: *bird6Enabled,
+		BirdEnabled:  *birdEnabled,
+		BirdV2:       *birdV2,
+	}
+
+	return &client.BirdClient{Options: o}
+}
+
+func exportersForLegacy(c *client.BirdClient) map[int][]metrics.MetricExporter {
 	l := &metrics.LegacyLabelStrategy{}
 
 	return map[int][]metrics.MetricExporter{
 		protocol.BGP:    []metrics.MetricExporter{metrics.NewLegacyMetricExporter("bgp4_session", "bgp6_session", l)},
 		protocol.Direct: []metrics.MetricExporter{metrics.NewLegacyMetricExporter("direct4", "direct6", l)},
 		protocol.Kernel: []metrics.MetricExporter{metrics.NewLegacyMetricExporter("kernel4", "kernel6", l)},
-		protocol.OSPF:   []metrics.MetricExporter{metrics.NewLegacyMetricExporter("ospf", "ospfv3", l), ospf.NewExporter("")},
+		protocol.OSPF:   []metrics.MetricExporter{metrics.NewLegacyMetricExporter("ospf", "ospfv3", l), metrics.NewOspfExporter("", c)},
 		protocol.Static: []metrics.MetricExporter{metrics.NewLegacyMetricExporter("static4", "static6", l)},
 	}
 }
 
-func exportersForDefault() map[int][]metrics.MetricExporter {
+func exportersForDefault(c *client.BirdClient) map[int][]metrics.MetricExporter {
 	l := &metrics.DefaultLabelStrategy{}
 	e := metrics.NewGenericProtocolMetricExporter("bird_protocol", true, l)
 
@@ -45,7 +59,7 @@ func exportersForDefault() map[int][]metrics.MetricExporter {
 		protocol.BGP:    []metrics.MetricExporter{e},
 		protocol.Direct: []metrics.MetricExporter{e},
 		protocol.Kernel: []metrics.MetricExporter{e},
-		protocol.OSPF:   []metrics.MetricExporter{e, ospf.NewExporter("bird_")},
+		protocol.OSPF:   []metrics.MetricExporter{e, metrics.NewOspfExporter("bird_", c)},
 		protocol.Static: []metrics.MetricExporter{e},
 	}
 }
@@ -59,8 +73,14 @@ func (m *MetricCollector) Describe(ch chan<- *prometheus.Desc) {
 }
 
 func (m *MetricCollector) Collect(ch chan<- prometheus.Metric) {
-	for _, p := range m.protocols {
-		if p.Proto == protocol.PROTO_UNKNOWN || (m.enabledProtocols & p.Proto != p.Proto) {
+	protocols, err := m.client.GetProtocols()
+	if err != nil {
+		log.Errorln(err)
+		return
+	}
+
+	for _, p := range protocols {
+		if p.Proto == protocol.PROTO_UNKNOWN || (m.enabledProtocols&p.Proto != p.Proto) {
 			continue
 		}
 
diff --git a/metrics/ospf_exporter.go b/metrics/ospf_exporter.go
new file mode 100644
index 0000000..43902fa
--- /dev/null
+++ b/metrics/ospf_exporter.go
@@ -0,0 +1,73 @@
+package metrics
+
+import (
+	"github.com/czerwonk/bird_exporter/client"
+	"github.com/czerwonk/bird_exporter/protocol"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/common/log"
+)
+
+type ospfDesc struct {
+	runningDesc               *prometheus.Desc
+	interfaceCountDesc        *prometheus.Desc
+	neighborCountDesc         *prometheus.Desc
+	neighborAdjacentCountDesc *prometheus.Desc
+}
+
+type ospfMetricExporter struct {
+	descriptions map[string]*ospfDesc
+	client       client.Client
+}
+
+func NewOspfExporter(prefix string, client client.Client) MetricExporter {
+	d := make(map[string]*ospfDesc)
+	d["4"] = getDesc(prefix + "ospf")
+	d["6"] = getDesc(prefix + "ospfv3")
+
+	return &ospfMetricExporter{descriptions: d, client: client}
+}
+
+func getDesc(prefix string) *ospfDesc {
+	labels := []string{"name"}
+
+	d := &ospfDesc{}
+	d.runningDesc = prometheus.NewDesc(prefix+"_running", "State of OSPF: 0 = Alone, 1 = Running (Neighbor-Adjacencies established)", labels, nil)
+
+	labels = append(labels, "area")
+	d.interfaceCountDesc = prometheus.NewDesc(prefix+"_interface_count", "Number of interfaces in the area", labels, nil)
+	d.neighborCountDesc = prometheus.NewDesc(prefix+"_neighbor_count", "Number of neighbors in the area", labels, nil)
+	d.neighborAdjacentCountDesc = prometheus.NewDesc(prefix+"_neighbor_adjacent_count", "Number of adjacent neighbors in the area", labels, nil)
+
+	return d
+}
+
+func (m *ospfMetricExporter) Describe(ch chan<- *prometheus.Desc) {
+	m.describe("4", ch)
+	m.describe("6", ch)
+}
+
+func (m *ospfMetricExporter) describe(ipVersion string, ch chan<- *prometheus.Desc) {
+	d := m.descriptions[ipVersion]
+	ch <- d.runningDesc
+	ch <- d.interfaceCountDesc
+	ch <- d.neighborCountDesc
+	ch <- d.neighborAdjacentCountDesc
+}
+
+func (m *ospfMetricExporter) Export(p *protocol.Protocol, ch chan<- prometheus.Metric) {
+	d := m.descriptions[p.IpVersion]
+	ch <- prometheus.MustNewConstMetric(d.runningDesc, prometheus.GaugeValue, p.Attributes["running"], p.Name)
+
+	areas, err := m.client.GetOspfAreas(p)
+	if err != nil {
+		log.Errorln(err)
+		return
+	}
+
+	for _, area := range areas {
+		l := []string{p.Name, area.Name}
+		ch <- prometheus.MustNewConstMetric(d.interfaceCountDesc, prometheus.GaugeValue, float64(area.InterfaceCount), l...)
+		ch <- prometheus.MustNewConstMetric(d.neighborCountDesc, prometheus.GaugeValue, float64(area.NeighborCount), l...)
+		ch <- prometheus.MustNewConstMetric(d.neighborAdjacentCountDesc, prometheus.GaugeValue, float64(area.NeighborAdjacentCount), l...)
+	}
+}
diff --git a/ospf/exporter.go b/ospf/exporter.go
deleted file mode 100644
index ff7d534..0000000
--- a/ospf/exporter.go
+++ /dev/null
@@ -1,41 +0,0 @@
-package ospf
-
-import (
-	"github.com/czerwonk/bird_exporter/metrics"
-	"github.com/czerwonk/bird_exporter/protocol"
-	"github.com/prometheus/client_golang/prometheus"
-)
-
-type desc struct {
-	runningDesc *prometheus.Desc
-}
-
-type ospfMetricExporter struct {
-	descriptions map[string]*desc
-}
-
-func NewExporter(prefix string) metrics.MetricExporter {
-	d := make(map[string]*desc)
-	d["4"] = getDesc(prefix + "ospf")
-	d["6"] = getDesc(prefix + "ospfv3")
-
-	return &ospfMetricExporter{descriptions: d}
-}
-
-func getDesc(prefix string) *desc {
-	labels := []string{"name"}
-
-	d := &desc{}
-	d.runningDesc = prometheus.NewDesc(prefix+"_running", "State of OSPF: 0 = Alone, 1 = Running (Neighbor-Adjacencies established)", labels, nil)
-
-	return d
-}
-
-func (m *ospfMetricExporter) Describe(ch chan<- *prometheus.Desc) {
-	ch <- m.descriptions["4"].runningDesc
-	ch <- m.descriptions["6"].runningDesc
-}
-
-func (m *ospfMetricExporter) Export(p *protocol.Protocol, ch chan<- prometheus.Metric) {
-	ch <- prometheus.MustNewConstMetric(m.descriptions[p.IpVersion].runningDesc, prometheus.GaugeValue, p.Attributes["running"], p.Name)
-}
diff --git a/parser/ospf.go b/parser/ospf.go
new file mode 100644
index 0000000..71817cc
--- /dev/null
+++ b/parser/ospf.go
@@ -0,0 +1,85 @@
+package parser
+
+import (
+	"regexp"
+
+	"bufio"
+	"bytes"
+	"strings"
+
+	"github.com/czerwonk/bird_exporter/protocol"
+)
+
+type ospfRegex struct {
+	area     *regexp.Regexp
+	counters *regexp.Regexp
+}
+
+type ospfContext struct {
+	line    string
+	areas   []*protocol.OspfArea
+	current *protocol.OspfArea
+}
+
+func init() {
+	ospf = &ospfRegex{
+		area:     regexp.MustCompile("Area: [^\\s]+ \\(([^\\s]+)\\)"),
+		counters: regexp.MustCompile("Number of ([^:]+):\\s*(\\d+)"),
+	}
+}
+
+var ospf *ospfRegex
+
+func ParseOspf(data []byte) []*protocol.OspfArea {
+	reader := bytes.NewReader(data)
+	scanner := bufio.NewScanner(reader)
+
+	c := &ospfContext{
+		areas: make([]*protocol.OspfArea, 0),
+	}
+
+	for scanner.Scan() {
+		c.line = strings.Trim(scanner.Text(), " ")
+		parseLineForOspfArea(c)
+		parseLineForOspfCounters(c)
+	}
+
+	return c.areas
+}
+
+func parseLineForOspfArea(c *ospfContext) {
+	m := ospf.area.FindStringSubmatch(c.line)
+	if m == nil {
+		return
+	}
+
+	a := &protocol.OspfArea{Name: m[1]}
+	c.current = a
+	c.areas = append(c.areas, a)
+}
+
+func parseLineForOspfCounters(c *ospfContext) {
+	if c.current == nil {
+		return
+	}
+
+	m := ospf.counters.FindStringSubmatch(c.line)
+	if m == nil {
+		return
+	}
+
+	name := m[1]
+	value := parseInt(m[2])
+
+	if name == "interfaces" {
+		c.current.InterfaceCount = value
+	}
+
+	if name == "neighbors" {
+		c.current.NeighborCount = value
+	}
+
+	if name == "adjacent neighbors" {
+		c.current.NeighborAdjacentCount = value
+	}
+}
diff --git a/parser/parser.go b/parser/parser.go
index 07b9a81..1cdb634 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -38,7 +38,7 @@ func init() {
 }
 
 // Parser parses bird output and returns protocol.Protocol structs
-func Parse(data []byte, ipVersion string) []*protocol.Protocol {
+func ParseProtocols(data []byte, ipVersion string) []*protocol.Protocol {
 	reader := bytes.NewReader(data)
 	scanner := bufio.NewScanner(reader)
 
diff --git a/parser_test.go b/parser_test.go
index c6f02e4..d0f1641 100644
--- a/parser_test.go
+++ b/parser_test.go
@@ -10,7 +10,7 @@ import (
 
 func TestEstablishedBgpOldTimeFormat(t *testing.T) {
 	data := "foo    BGP      master   up     1481973060  Established\ntest\nbar\n  Routes:         12 imported, 1 filtered, 34 exported, 100 preferred\nxxx"
-	p := parser.Parse([]byte(data), "4")
+	p := parser.ParseProtocols([]byte(data), "4")
 	assert.IntEqual("protocols", 1, len(p), t)
 
 	x := p[0]
@@ -26,7 +26,7 @@ func TestEstablishedBgpOldTimeFormat(t *testing.T) {
 
 func TestEstablishedBgpCurrentTimeFormat(t *testing.T) {
 	data := "foo    BGP      master   up     00:01:00  Established\ntest\nbar\n  Routes:         12 imported, 1 filtered, 34 exported, 100 preferred\nxxx"
-	p := parser.Parse([]byte(data), "4")
+	p := parser.ParseProtocols([]byte(data), "4")
 	assert.IntEqual("protocols", 1, len(p), t)
 
 	x := p[0]
@@ -43,7 +43,7 @@ func TestEstablishedBgpCurrentTimeFormat(t *testing.T) {
 
 func TestIpv6Bgp(t *testing.T) {
 	data := "foo    BGP      master   up     00:01:00  Established\ntest\nbar\n  Routes:         12 imported, 1 filtered, 34 exported, 100 preferred\nxxx"
-	p := parser.Parse([]byte(data), "6")
+	p := parser.ParseProtocols([]byte(data), "6")
 	assert.IntEqual("protocols", 1, len(p), t)
 
 	x := p[0]
@@ -52,7 +52,7 @@ func TestIpv6Bgp(t *testing.T) {
 
 func TestActiveBgp(t *testing.T) {
 	data := "bar    BGP      master   start   2016-01-01    Active\ntest\nbar"
-	p := parser.Parse([]byte(data), "4")
+	p := parser.ParseProtocols([]byte(data), "4")
 	assert.IntEqual("protocols", 1, len(p), t)
 
 	x := p[0]
@@ -67,7 +67,7 @@ func TestActiveBgp(t *testing.T) {
 
 func Test2BgpSessions(t *testing.T) {
 	data := "foo    BGP      master   up     00:01:00  Established\ntest\n  Routes:         12 imported, 1 filtered, 34 exported, 100 preferred\nbar    BGP      master   start   2016-01-01    Active\nxxx"
-	p := parser.Parse([]byte(data), "4")
+	p := parser.ParseProtocols([]byte(data), "4")
 	assert.IntEqual("protocols", 2, len(p), t)
 }
 
@@ -79,7 +79,7 @@ func TestUpdateAndWithdrawCounts(t *testing.T) {
 		"    Import withdraws:            6          7          8          9         10\n" +
 		"    Export updates:             11         12         13         14         15\n" +
 		"    Export withdraws:           16         17         18         19        ---"
-	p := parser.Parse([]byte(data), "4")
+	p := parser.ParseProtocols([]byte(data), "4")
 	x := p[0]
 
 	assert.Int64Equal("import updates received", 1, x.ImportUpdates.Received, t)
@@ -141,7 +141,7 @@ func TestWithBird2(t *testing.T) {
 		"    Routes:         4 imported, 3 filtered, 2 exported, 1 preferred\n" +
 		"\n"
 
-	p := parser.Parse([]byte(data), "")
+	p := parser.ParseProtocols([]byte(data), "")
 	assert.IntEqual("protocols", 4, len(p), t)
 
 	x := p[0]
@@ -223,7 +223,7 @@ func TestWithBird2(t *testing.T) {
 
 func TestOspfOldTimeFormat(t *testing.T) {
 	data := "ospf1    OSPF      master   up     1481973060  Running\ntest\nbar\n  Routes:         12 imported, 34 exported, 100 preferred\nxxx"
-	p := parser.Parse([]byte(data), "4")
+	p := parser.ParseProtocols([]byte(data), "4")
 	assert.IntEqual("protocols", 1, len(p), t)
 
 	x := p[0]
@@ -238,7 +238,7 @@ func TestOspfOldTimeFormat(t *testing.T) {
 
 func TestOspfCurrentTimeFormat(t *testing.T) {
 	data := "ospf1    OSPF      master   up     00:01:00  Running\ntest\nbar\n  Routes:         12 imported, 34 exported, 100 preferred\nxxx"
-	p := parser.Parse([]byte(data), "4")
+	p := parser.ParseProtocols([]byte(data), "4")
 	assert.IntEqual("protocols", 1, len(p), t)
 
 	x := p[0]
@@ -254,7 +254,7 @@ func TestOspfCurrentTimeFormat(t *testing.T) {
 
 func TestOspfProtocolDown(t *testing.T) {
 	data := "o_hrz    OSPF     t_hrz    down   1494926415  \n  Preference:     150\n  Input filter:   ACCEPT\n  Output filter:  REJECT\nxxx"
-	p := parser.Parse([]byte(data), "6")
+	p := parser.ParseProtocols([]byte(data), "6")
 	assert.IntEqual("protocols", 1, len(p), t)
 
 	x := p[0]
@@ -268,7 +268,7 @@ func TestOspfProtocolDown(t *testing.T) {
 
 func TestOspfRunning(t *testing.T) {
 	data := "ospf1    OSPF      master   up     00:01:00  Running\ntest\nbar\n  Routes:         12 imported, 34 exported, 100 preferred\nxxx"
-	p := parser.Parse([]byte(data), "4")
+	p := parser.ParseProtocols([]byte(data), "4")
 	assert.IntEqual("protocols", 1, len(p), t)
 
 	x := p[0]
@@ -277,9 +277,46 @@ func TestOspfRunning(t *testing.T) {
 
 func TestOspfAlone(t *testing.T) {
 	data := "ospf1    OSPF      master   up     00:01:00  Alone\ntest\nbar\n  Routes:         12 imported, 34 exported, 100 preferred\nxxx"
-	p := parser.Parse([]byte(data), "4")
+	p := parser.ParseProtocols([]byte(data), "4")
 	assert.IntEqual("protocols", 1, len(p), t)
 
 	x := p[0]
 	assert.Float64Equal("running", 0, x.Attributes["running"], t)
 }
+
+func TestOspfArea(t *testing.T) {
+	data := "ospf1:\n" +
+		"RFC1583 compatibility: disabled\n" +
+		"Stub router: No\n" +
+		"RT scheduler tick: 1\n" +
+		"Number of areas: 2\n" +
+		"Number of LSAs in DB:   33\n" +
+		"    Area: 0.0.0.0 (0) [BACKBONE]\n" +
+		"        Stub:   No\n" +
+		"        NSSA:   No\n" +
+		"        Transit:    No\n" +
+		"        Number of interfaces:   3\n" +
+		"        Number of neighbors:    2\n" +
+		"        Number of adjacent neighbors:   1\n" +
+		"    Area: 0.0.0.1 (1)\n" +
+		"        Stub:   No\n" +
+		"        NSSA:   No\n" +
+		"        Transit:    No\n" +
+		"        Number of interfaces:   4\n" +
+		"        Number of neighbors:    6\n" +
+		"        Number of adjacent neighbors:   5\n"
+	a := parser.ParseOspf([]byte(data))
+	assert.IntEqual("areas", 2, len(a), t)
+
+	a1 := a[0]
+	assert.StringEqual("Area1 Name", "0", a1.Name, t)
+	assert.Int64Equal("Area1 InterfaceCount", 3, a1.InterfaceCount, t)
+	assert.Int64Equal("Area1 NeighborCount", 2, a1.NeighborCount, t)
+	assert.Int64Equal("Area1 NeighborAdjacentCount", 1, a1.NeighborAdjacentCount, t)
+
+	a2 := a[1]
+	assert.StringEqual("Area2 Name", "1", a2.Name, t)
+	assert.Int64Equal("Area2 InterfaceCount", 4, a2.InterfaceCount, t)
+	assert.Int64Equal("Area2 NeighborCount", 6, a2.NeighborCount, t)
+	assert.Int64Equal("Area2 NeighborAdjacentCount", 5, a2.NeighborAdjacentCount, t)
+}
diff --git a/protocol/ospf_area.go b/protocol/ospf_area.go
new file mode 100644
index 0000000..7516b54
--- /dev/null
+++ b/protocol/ospf_area.go
@@ -0,0 +1,8 @@
+package protocol
+
+type OspfArea struct {
+	Name                  string
+	InterfaceCount        int64
+	NeighborCount         int64
+	NeighborAdjacentCount int64
+}